Notifications.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\GlobalScreen\Client;
 
use ILIAS\DI\Container;
use ILIAS\Filesystem\Stream\Streams;
use ILIAS\GlobalScreen\Scope\MainMenu\Collector\Renderer\Hasher;
use ILIAS\HTTP\Response\ResponseHeader;
use ILIAS\HTTP\Response\Sender\ResponseSendingException;
use JsonException;
 
class Notifications
{
    use Hasher;
 
    public const ADDITIONAL_ACTION = 'additional_action';
    private ?string $additional_action = null;
    protected Container $dic;
    protected array $notification_groups;
    public const MODE = "mode";
    public const MODE_OPENED = "opened";
    public const MODE_CLOSED = "closed";
    public const MODE_HANDLE_TOAST_ACTION = "toast_action";
    public const MODE_RERENDER = "rerender";
    public const ITEM_ID = "item_id";
    public const NOTIFICATION_IDENTIFIERS = "notification_identifiers";
    public const NOTIFY_ENDPOINT = "src/GlobalScreen/Client/notify.php";
    protected array $identifiers_to_handle = [];
    protected ?string $single_identifier_to_handle = null;
    protected array $administrative_notifications = [];
    private array $toasts = [];
 
    public function __construct()
    {
        global $DIC;
        $this->dic = $DIC;
    }
 
    public function run(): void
    {
        global $DIC;
        $this->notification_groups = $DIC->globalScreen()->collector()->notifications()->getNotifications();
        $this->administrative_notifications = $DIC->globalScreen()->collector()->notifications(
        )->getAdministrativeNotifications();
        $this->identifiers_to_handle = $DIC->http()->request()->getQueryParams()[self::NOTIFICATION_IDENTIFIERS] ?? [];
        $this->single_identifier_to_handle = $DIC->http()->request()->getQueryParams()[self::ITEM_ID] ?? null;
        $this->toasts = $DIC->globalScreen()->collector()->toasts()->getToasts();
 
        $query = $DIC->http()->wrapper()->query();
 
        $this->additional_action = $query->has(self::ADDITIONAL_ACTION)
            ? $query->retrieve(
                self::ADDITIONAL_ACTION,
                $DIC->refinery()->kindlyTo()->string()
            )
            : null;
 
        $mode = 'none';
        if ($query->has(self::MODE)) {
            $mode = $query->retrieve(self::MODE, $DIC->refinery()->to()->string());
        }
 
        switch ($mode) {
            case self::MODE_OPENED:
                $this->handleOpened();
                break;
            case self::MODE_CLOSED:
                $this->handleClosed();
                break;
            case self::MODE_RERENDER:
                $this->handleRerender();
                break;
            case self::MODE_HANDLE_TOAST_ACTION:
                $this->handleToastAction();
                break;
        }
    }
 
    private function handleToastAction(): void
    {
        foreach ($this->toasts as $toast) {
            if ($this->hash($toast->getProviderIdentification()->serialize()) === $this->single_identifier_to_handle) {
                foreach ($toast->getAllToastActions() as $toast_action) {
                    if ($toast_action->getIdentifier() === $this->additional_action) {
                        $callable = $toast_action->getAction();
                        $callable();
                        return;
                    }
                }
            }
        }
    }
 
    private function handleOpened(): void
    {
        foreach ($this->notification_groups as $notification_group) {
            foreach ($notification_group->getNotifications() as $notification) {
                if (in_array(
                    $this->hash($notification->getProviderIdentification()->serialize()),
                    $this->identifiers_to_handle,
                    true
                )) {
                    $notification->getOpenedCallable()();
                }
            }
            if (in_array(
                $this->hash($notification_group->getProviderIdentification()->serialize()),
                $this->identifiers_to_handle,
                true
            )) {
                $notification_group->getOpenedCallable()();
            }
        }
    }
 
    private function handleClosed(): void
    {
        foreach ($this->notification_groups as $notification_group) {
            foreach ($notification_group->getNotifications() as $notification) {
                if ($this->single_identifier_to_handle !== $this->hash(
                    $notification->getProviderIdentification()->serialize()
                )) {
                    continue;
                }
                if (!$notification->hasClosedCallable()) {
                    continue;
                }
                $notification->getClosedCallable()();
            }
        }
        foreach ($this->administrative_notifications as $administrative_notification) {
            if ($this->single_identifier_to_handle !== $this->hash(
                $administrative_notification->getProviderIdentification()->serialize()
            )) {
                continue;
            }
            if (!$administrative_notification->hasClosedCallable()) {
                continue;
            }
            $administrative_notification->getClosedCallable()();
        }
    }
 
    private function handleRerender(): void
    {
        $notifications = [];
        $amount = 0;
        foreach ($this->notification_groups as $group) {
            $notifications[] = $group->getRenderer($this->dic->ui()->factory())->getNotificationComponentForItem(
                $group
            );
            if ($group->getNewNotificationsCount() > 0) {
                $amount++;
            }
        }
        $this->dic->http()->saveResponse(
            $this->dic->http()->response()
                      ->withBody(
                          Streams::ofString(
                              json_encode([
                                  'html' => $this->dic->ui()->renderer()->renderAsync($notifications),
                                  'symbol' => $this->dic->ui()->renderer()->render(
                                      $this->dic->ui()->factory()->symbol()->glyph()->notification()->withCounter(
                                          $this->dic->ui()->factory()->counter()->novelty($amount)
                                      )
                                  )
                              ], JSON_THROW_ON_ERROR)
                          )
                      )
                      ->withHeader(ResponseHeader::CONTENT_TYPE, 'application/json')
        );
        $this->dic->http()->sendResponse();
        $this->dic->http()->close();
    }
}