AbstractComponentRenderer.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\UI\Implementation\Render;
 
use ILIAS\Data\Factory as DataFactory;
use ILIAS\UI\Component\Component;
use ILIAS\UI\Component\JavaScriptBindable;
use ILIAS\UI\Component\Triggerer;
use ILIAS\UI\Factory;
use ilLanguage;
use InvalidArgumentException;
use LogicException;
 
abstract class AbstractComponentRenderer implements ComponentRenderer
{
    private Factory $ui_factory;
    private TemplateFactory $tpl_factory;
    private ilLanguage $lng;
    private JavaScriptBinding $js_binding;
    private static array $component_storage = [];
    private \ILIAS\Refinery\Factory $refinery;
    private ImagePathResolver $image_path_resolver;
    private DataFactory $data_factory;
 
 
    final public function __construct(
        Factory $ui_factory,
        TemplateFactory $tpl_factory,
        ilLanguage $lng,
        JavaScriptBinding $js_binding,
        \ILIAS\Refinery\Factory $refinery,
        ImagePathResolver $image_path_resolver,
        DataFactory $data_factory
    ) {
        $this->ui_factory = $ui_factory;
        $this->tpl_factory = $tpl_factory;
        $this->lng = $lng;
        $this->js_binding = $js_binding;
        $this->refinery = $refinery;
        $this->image_path_resolver = $image_path_resolver;
        $this->data_factory = $data_factory;
    }
 
    public function registerResources(ResourceRegistry $registry): void
    {
        $registry->register('./src/UI/templates/js/Core/dist/core.js');
    }
 
    final protected function getUIFactory(): Factory
    {
        return $this->ui_factory;
    }
 
    final protected function getDataFactory(): DataFactory
    {
        return $this->data_factory;
    }
 
    final protected function getRefinery(): \ILIAS\Refinery\Factory
    {
        return $this->refinery;
    }
 
    final public function txt(string $id): string
    {
        return $this->lng->txt($id);
    }
 
    final public function toJS($key): void
    {
        $this->lng->toJS($key);
    }
 
    public function getLangKey(): string
    {
        return $this->lng->getLangKey();
    }
 
    final protected function getJavascriptBinding(): JavaScriptBinding
    {
        return $this->js_binding;
    }
 
    final protected function getTemplate(string $name, bool $purge_unfilled_vars, bool $purge_unused_blocks): Template
    {
        $path = $this->getTemplatePath($name);
        return $this->tpl_factory->getTemplate($path, $purge_unfilled_vars, $purge_unused_blocks);
    }
 
    protected function getTemplatePath(string $name): string
    {
        $component = $this->getMyComponent();
        return "src/UI/templates/default/$component/$name";
    }
 
    final protected function bindJavaScript(JavaScriptBindable $component): ?string
    {
        if ($component instanceof Triggerer) {
            $component = $this->addTriggererOnLoadCode($component);
        }
        return $this->bindOnloadCode($component);
    }
 
    final protected function createId(): string
    {
        return $this->js_binding->createId();
    }
 
    private function bindOnloadCode(JavaScriptBindable $component): ?string
    {
        $binder = $component->getOnLoadCode();
        if ($binder === null) {
            return null;
        }
 
        $id = $this->js_binding->createId();
        $on_load_code = $binder($id);
        if (!is_string($on_load_code)) {
            throw new LogicException(
                "Expected JavaScript binder to return string" .
                " (used component: " . get_class($component) . ")"
            );
        }
        $this->js_binding->addOnLoadCode($on_load_code);
        return $id;
    }
 
    private function addTriggererOnLoadCode(Triggerer $triggerer): JavaScriptBindable
    {
        $triggered_signals = $triggerer->getTriggeredSignals();
        if (count($triggered_signals) == 0) {
            return $triggerer;
        }
        return $triggerer->withAdditionalOnLoadCode(function ($id) use ($triggered_signals): string {
            $code = "";
            foreach ($triggered_signals as $triggered_signal) {
                $signal = $triggered_signal->getSignal();
                $event = $triggered_signal->getEvent();
                $options = json_encode($signal->getOptions());
                //Note this switch is necessary since $(#...).on('load', ...) could be fired before the binding of the event.
                //Same seems true fro ready, see: #27456
                if ($event == 'load' || $event == 'ready') {
                    $code .=
                            "$(document).trigger('$signal',
                                                        {
                                                                'id' : '$signal', 'event' : '$event',
                                                                'triggerer' : $('#$id'),
                                                                'options' : JSON.parse('$options')
                                                        }
                                                );";
                } else {
                    $code .=
                    "$('#$id').on('$event', function(event) {
                                                $(this).trigger('$signal',
                                                        {
                                                                'id' : '$signal', 'event' : '$event',
                                                                'triggerer' : $(this),
                                                                'options' : JSON.parse('$options')
                                                        }
                                                );
                                                return false;
                                        });";
                }
            }
            return $code;
        });
    }
 
    final protected function checkComponent(Component $component): void
    {
        $interfaces = $this->getComponentInterfaceName();
        if (!is_array($interfaces)) {
            throw new LogicException(
                "Expected array, found '" . (string) (null) . "' when rendering."
            );
        }
 
        foreach ($interfaces as $interface) {
            if ($component instanceof $interface) {
                return;
            }
        }
        $ifs = implode(", ", $interfaces);
        throw new LogicException(
            "Expected $ifs, found '" . get_class($component) . "' when rendering."
        );
    }
 
    abstract protected function getComponentInterfaceName(): array;
 
    private function getMyComponent()
    {
        $class = get_class($this);
        if (isset(self::$component_storage[$class])) {
            return self::$component_storage[$class];
        }
        $matches = array();
        // Extract component
        $re = "%ILIAS\\\\UI\\\\Implementation\\\\Component\\\\(\\w+)\\\\(\\w+)%";
        preg_match($re, $class, $matches);
        if (preg_match($re, $class, $matches) !== 1) {
            throw new LogicException("The Renderer needs to be located in ILIAS\\UI\\Implementation\\Component\\*.");
        }
        self::$component_storage[$class] = $matches[1];
 
        return self::$component_storage[$class];
    }
 
    public function getImagePathResolver(): ImagePathResolver
    {
        return $this->image_path_resolver;
    }
 
    protected function convertSpecialCharacters(string $value): string
    {
        return htmlspecialchars($value, ENT_QUOTES | ENT_SUBSTITUTE, 'utf-8');
    }
}