NodeRetrieval.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\StaticURL\Shortlinks\UI;
 
use ILIAS\Language\Language;
use ILIAS\UI\URLBuilderToken;
use ILIAS\UI\URLBuilder;
use ILIAS\Data\URI;
use ILIAS\UI\Component\Symbol\Icon\Icon;
use ILIAS\UI\Component\Input\Field\Node\NodeRetrieval as UINodeRetrieval;
use ILIAS\UI\Component\Input\Field\Node\Factory as NodeFactory;
use ILIAS\UI\Component\Symbol\Icon\Factory as IconFactory;
 
class NodeRetrieval implements UINodeRetrieval
{
    protected const string NODE_SORT_BY = 'title';
 
    protected array $node_object_type_list;
 
    public function __construct(
        protected Language $language,
        protected \ILIAS\Data\Factory $data_factory,
        protected URLBuilderToken $async_node_id_parameter,
        protected URLBuilder $async_node_url_builder,
        protected \ilAccess $access,
        protected \ilTree $tree,
        protected array $branch_object_type_list,
        protected array $leaf_object_type_list,
        protected int $max_branch_node_depth,
        protected int $root_node_id,
    ) {
        $this->node_object_type_list = array_merge($this->branch_object_type_list, $this->leaf_object_type_list);
    }
 
    public function getNodes(
        NodeFactory $node_factory,
        IconFactory $icon_factory,
        ?string $parent_id = null,
    ): \Generator {
        yield from $this->createNodes($node_factory, $icon_factory, (int) ($parent_id ?? $this->root_node_id));
    }
 
    public function getNodesAsLeaf(
        NodeFactory $node_factory,
        IconFactory $icon_factory,
        array $node_ids,
    ): \Generator {
        foreach ($node_ids as $node_id) {
            try {
                $tree_node_data = $this->tree->getNodeData((int) $node_id);
                [$object_ref_id, $object_type, $object_title] = $this->extractObjectDataOrAbort($tree_node_data);
                yield $node_factory->leaf(
                    $object_ref_id,
                    $object_title,
                    $this->getObjectIcon($icon_factory, $object_ref_id, $object_type),
                );
            } catch (\LogicException) {
                yield $node_factory->leaf($node_id, $this->language->txt('unknown'));
            }
        }
    }
 
    protected function createNodes(
        NodeFactory $node_factory,
        IconFactory $icon_factory,
        int $parent_object_id,
        int $depth = 0,
    ): array {
        $children = $this->tree->getChildsByTypeFilter(
            $parent_object_id,
            $this->node_object_type_list,
            self::NODE_SORT_BY,
        );
 
        $nodes = [];
        foreach ($children as $child) {
            [$object_ref_id, $object_type, $object_title] = $this->extractObjectDataOrAbort($child);
 
            $is_object_visible = $this->isObjectVisible($object_ref_id, $object_type);
            $is_object_container = $this->isObjectContainer($object_type);
 
            // append visible children of an invisible branch node to the current node.
            if (!$is_object_visible && $is_object_container) {
                $nodes = [...$nodes, ...$this->createNodes($node_factory, $icon_factory, $object_ref_id, $depth + 1)];
                continue;
            }
 
            $object_icon = $this->getObjectIcon($icon_factory, $object_ref_id, $object_type);
 
            if ($is_object_visible && $is_object_container) {
                if ($depth < $this->max_branch_node_depth) {
                    $nodes[] = $node_factory->branch(
                        $object_ref_id,
                        $object_title,
                        $object_icon,
                        ...$this->createNodes($node_factory, $icon_factory, $object_ref_id, $depth + 1),
                    );
                } else {
                    $nodes[] = $node_factory->async(
                        $this->getAsyncRenderUrl($object_ref_id),
                        $object_ref_id,
                        $object_title,
                        $object_icon,
                    );
                }
                continue;
            }
            if ($is_object_visible && !$is_object_container) {
                $nodes[] = $node_factory->leaf($object_ref_id, $object_title, $object_icon);
            }
        }
        return $nodes;
    }
 
    protected function extractObjectDataOrAbort(array $tree_node_data): array
    {
        $object_ref_id = $tree_node_data['ref_id'] ?? null;
        $object_type = $tree_node_data['type'] ?? null;
        $object_title = $tree_node_data['title'] ?? null;
        if (in_array(null, [$object_ref_id, $object_type, $object_title], true)) {
            throw new \LogicException("Object data is invalid");
        }
        return [$object_ref_id, $object_type, $object_title];
    }
 
    protected function getAsyncRenderUrl(int $object_ref_id): URI
    {
        $async_node_url_builder = $this->async_node_url_builder->withParameter(
            $this->async_node_id_parameter,
            (string) $object_ref_id
        );
        return $this->data_factory->uri((string) $async_node_url_builder->buildURI());
    }
 
    protected function getObjectIcon(IconFactory $icon_factory, int $object_ref_id, string $object_type): Icon
    {
        // ensures plugin object types are properly handled as well.
        $icon_path = \ilObject::_getIcon(\ilObject::_lookupObjectId($object_ref_id), Icon::SMALL);
 
        if ($this->tree->getRootId() >= $object_ref_id) {
            $alt_text = $this->language->txt('repository');
        } else {
            $alt_text = $this->language->txt($object_type);
        }
        return $icon_factory->custom($icon_path, $alt_text, Icon::SMALL);
    }
 
    protected function isObjectVisible(int $object_ref_id, string $object_type = ''): bool
    {
        return $this->access->checkAccess('visible', '', $object_ref_id, $object_type);
    }
 
    protected function isObjectContainer(string $object_type): bool
    {
        return in_array($object_type, $this->branch_object_type_list, true);
    }
 
}