InternalServices.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\MetaData\Editor\Services;
 
use ILIAS\MetaData\Editor\Manipulator\ManipulatorInterface;
use ILIAS\MetaData\Editor\Manipulator\Manipulator;
use ILIAS\MetaData\Editor\Presenter\Presenter;
use ILIAS\MetaData\Editor\Presenter\PresenterInterface;
use ILIAS\MetaData\Editor\Presenter\Utilities;
use ILIAS\MetaData\Editor\Presenter\Data;
use ILIAS\MetaData\Editor\Presenter\Elements;
use ILIAS\DI\Container as GlobalContainer;
use ILIAS\MetaData\Paths\Services\Services as PathServices;
use ILIAS\MetaData\Structure\Services\Services as StructureServices;
use ILIAS\MetaData\Editor\Dictionary\LOMDictionaryInitiator;
use ILIAS\MetaData\Editor\Dictionary\TagFactory;
use ILIAS\MetaData\Editor\Http\LinkFactoryInterface;
use ILIAS\MetaData\Editor\Http\RequestParserInterface;
use ILIAS\MetaData\Editor\Http\LinkFactory;
use ILIAS\Data\Factory as DataFactory;
use ILIAS\MetaData\Editor\Http\RequestParser;
use ILIAS\MetaData\Editor\Dictionary\DictionaryInterface;
use ILIAS\MetaData\Repository\Services\Services as RepositoryServices;
use ILIAS\MetaData\Editor\Observers\ObserverHandler;
use ILIAS\MetaData\Editor\Observers\ObserverHandlerInterface;
use ILIAS\MetaData\Manipulator\Services\Services as ManipulatorServices;
use ILIAS\MetaData\Presentation\Services\Services as PresentationServices;
use ILIAS\MetaData\Vocabularies\Services\Services as VocabulariesServices;
use ILIAS\MetaData\Editor\Vocabulary\AdapterInterface as VocabularyAdapterInterface;
use ILIAS\MetaData\Editor\Vocabulary\Adapter as VocabularyAdapter;
 
class InternalServices
{
    protected PresenterInterface $presenter;
    protected DictionaryInterface $dictionary;
    protected LinkFactoryInterface $link_factory;
    protected RequestParserInterface $request_parser;
    protected ObserverHandlerInterface $observer_handler;
    protected ManipulatorInterface $manipulator;
    protected VocabularyAdapterInterface $vocabulary_adapter;
 
    public function __construct(
        protected GlobalContainer $dic,
        protected PathServices $path_services,
        protected StructureServices $structure_services,
        protected RepositoryServices $repository_services,
        protected ManipulatorServices $manipulator_services,
        protected PresentationServices $presentation_services,
        protected VocabulariesServices $vocabularies_services
    ) {
    }
 
    public function presenter(): PresenterInterface
    {
        return $this->presenter ??= new Presenter(
            new Utilities(
                $this->presentation_services->utilities()
            ),
            $data = new Data(
                $this->presentation_services->utilities(),
                $this->presentation_services->data(),
                $this->vocabularies_services->presentation()
            ),
            new Elements(
                $data,
                $this->dictionary(),
                $this->path_services->navigatorFactory(),
                $this->presentation_services->elements()
            ),
        );
    }
 
    public function dictionary(): DictionaryInterface
    {
        return $this->dictionary ??= (new LOMDictionaryInitiator(
            new TagFactory($this->path_services->pathFactory()),
            $this->path_services->pathFactory(),
            $this->path_services->navigatorFactory(),
            $this->structure_services->structure()
        ))->get();
    }
 
    public function linkFactory(): LinkFactoryInterface
    {
        return $this->link_factory ??= new LinkFactory(
            $this->dic->ctrl(),
            new DataFactory()
        );
    }
 
    public function requestParser(): RequestParserInterface
    {
        return $this->request_parser ??= new RequestParser(
            $this->dic->http(),
            $this->dic->refinery(),
            $this->path_services->pathFactory()
        );
    }
 
    public function manipulator(): ManipulatorInterface
    {
        return $this->manipulator ??= new Manipulator(
            $this->manipulator_services->manipulator(),
            $this->path_services->navigatorFactory(),
            $this->repository_services->repository(),
            $this->manipulator_services->scaffoldProvider()
        );
    }
 
    public function observerHandler(): ObserverHandlerInterface
    {
        return $this->observer_handler ??= new ObserverHandler();
    }
 
    public function vocabularyAdapter(): VocabularyAdapterInterface
    {
        return $this->vocabulary_adapter ??= new VocabularyAdapter(
            $this->vocabularies_services->reader(),
            $this->vocabularies_services->slotElementHelper()
        );
    }
}