MainToolCollector.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
namespace ILIAS\GlobalScreen\Scope\Tool\Collector;
 
use ILIAS\GlobalScreen\Collector\AbstractBaseCollector;
use ILIAS\GlobalScreen\Collector\ItemCollector;
use ILIAS\GlobalScreen\Scope\MainMenu\Collector\Information\ItemInformation;
use ILIAS\GlobalScreen\Scope\MainMenu\Collector\Information\TypeInformation;
use ILIAS\GlobalScreen\Scope\MainMenu\Collector\Information\TypeInformationCollection;
use ILIAS\GlobalScreen\Scope\Tool\Collector\Renderer\ToolItemRenderer;
use ILIAS\GlobalScreen\Scope\Tool\Collector\Renderer\TreeToolItemRenderer;
use ILIAS\GlobalScreen\Scope\Tool\Factory\isToolItem;
use ILIAS\GlobalScreen\Scope\Tool\Factory\Tool;
use ILIAS\GlobalScreen\Scope\Tool\Factory\TreeTool;
use ILIAS\GlobalScreen\Scope\Tool\Provider\DynamicToolProvider;
use ILIAS\GlobalScreen\Identification\IdentificationInterface;
use Generator;
 
class MainToolCollector extends AbstractBaseCollector implements ItemCollector
{
    private TypeInformationCollection $type_information_collection;
    private array $tools = [];
 
    public function __construct(private array $providers, private ?ItemInformation $information = null)
    {
        $this->type_information_collection = new TypeInformationCollection();
 
        // Tool
        $tool = new TypeInformation(Tool::class, Tool::class, new ToolItemRenderer());
        $tool->setCreationPrevented(true);
        $this->type_information_collection->add($tool);
 
        $tool = new TypeInformation(TreeTool::class, TreeTool::class, new TreeToolItemRenderer());
        $tool->setCreationPrevented(true);
        $this->type_information_collection->add($tool);
    }
 
    public function collectStructure(): void
    {
        global $DIC;
        $called_contexts = $DIC->globalScreen()->tool()->context()->stack();
 
        $tools_to_merge = [];
 
        foreach ($this->providers as $provider) {
            $context_collection = $provider->isInterestedInContexts();
            if ($context_collection->hasMatch($called_contexts)) {
                $tools_to_merge[] = $provider->getToolsForContextStack($called_contexts);
            }
        }
        $this->tools = array_merge([], ...$tools_to_merge);
    }
 
    public function filterItemsByVisibilty(bool $async_only = false): void
    {
        $this->tools = array_filter($this->tools, $this->getVisibleFilter());
    }
 
    public function getSingleItem(IdentificationInterface $identification): isToolItem
    {
        foreach ($this->tools as $tool) {
            if ($tool->getProviderIdentification()->serialize() === $identification->serialize()) {
                return $tool;
            }
        }
        return new Tool($identification);
    }
 
    public function prepareItemsForUIRepresentation(): void
    {
        array_walk($this->tools, function (isToolItem $tool): void {
            $this->applyTypeInformation($tool);
        });
    }
 
    public function cleanupItemsForUIRepresentation(): void
    {
        // TODO: Implement cleanupItemsForUIRepresentation() method.
    }
 
    public function sortItemsForUIRepresentation(): void
    {
        usort($this->tools, $this->getItemSorter());
    }
 
    public function getItemsForUIRepresentation(): Generator
    {
        yield from $this->tools;
    }
 
    public function hasItems(): bool
    {
        return $this->tools !== [];
    }
 
 
    public function hasVisibleItems(): bool
    {
        return $this->hasItems();
    }
 
    private function applyTypeInformation(isToolItem $item): isToolItem
    {
        $item->setTypeInformation($this->getTypeInfoermationForItem($item));
 
        return $item;
    }
 
    private function getTypeInfoermationForItem(isToolItem $item): TypeInformation
    {
        $type = $item::class;
 
        return $this->type_information_collection->get($type);
    }
 
    private function getVisibleFilter(): callable
    {
        return static fn(isToolItem $tool): bool => $tool->isAvailable() && $tool->isVisible();
    }
 
    private function getItemSorter(): callable
    {
        return static fn(isToolItem $a, isToolItem $b): int => $a->getPosition() - $b->getPosition();
    }
}