class.ilADNNotification.php

Go to the documentation of this file.

<?php
class ilADNNotification extends ActiveRecord
{
    public const POS_TOP = 1;
    public const POS_RIGHT = 2;
    public const POST_LEFT = 3;
    public const POS_BOTTOM = 4;
    public const DATE_FORMAT = 'd.m.Y';
    public const TIME_FORMAT = 'H:i';
    public const DATE_TIME_FORMAT = 'd.m.Y H:i';
    public const TYPE_INFO = 1;
    public const TYPE_WARNING = 2;
    public const TYPE_ERROR = 3;
    public const TABLE_NAME = 'il_adn_notifications';
    public const LINK_TYPE_NONE = 0;
    public const LINK_TYPE_REF_ID = 1;
    public const LINK_TYPE_URL = 2;
    protected static array $allowed_user_ids = [0, 13, 6];

    #[\Override]
    public function getConnectorContainerName(): string
    {
        return self::TABLE_NAME;
    }

    public static function returnDbTableName(): string
    {
        return self::TABLE_NAME;
    }

    public function dismiss(ilObjUser $ilObjUser): void
    {
        if ($this->isUserAllowedToDismiss($ilObjUser)) {
            ilADNDismiss::dismiss($ilObjUser, $this);
        }
    }

    protected function hasUserDismissed(ilObjUser $ilObjUser): bool
    {
        if (!$this->getDismissable()) {
            return false;
        }

        return ilADNDismiss::hasDimissed($ilObjUser, $this);
    }

    public function resetForAllUsers(): void
    {
        foreach (ilADNDismiss::where(['notification_id' => $this->getId()])->get() as $not) {
            $not->delete();
        }
    }

    public function getFullTimeFormated(): string
    {
        if ($this->getEventStart() == 0 && $this->getEventEnd() == 0) {
            return '';
        }
        if (date(self::DATE_FORMAT, $this->getEventStart()) === date(self::DATE_FORMAT, $this->getEventEnd())) {
            return date(self::DATE_FORMAT, $this->getEventEnd()) . ', ' . date(
                self::TIME_FORMAT,
                $this->getEventStart()
            ) . " - "
                . date(self::TIME_FORMAT, $this->getEventEnd());
        }
        return date(self::DATE_TIME_FORMAT, $this->getEventStart()) . ' - ' . date(
            self::DATE_TIME_FORMAT,
            $this->getEventEnd()
        );
    }

    public function isUserAllowedToDismiss(ilObjUser $user): bool
    {
        return ($this->getDismissable() && $user->getId() !== 0 && $user->getId() !== ANONYMOUS_USER_ID);
    }

    public function getActiveType(): int
    {
        if ($this->isPermanent()) {
            return $this->getType();
        }
        if ($this->hasEventStarted() && !$this->hasEventEnded()) {
            return $this->getTypeDuringEvent();
        }
        if ($this->hasDisplayStarted() && !$this->hasDisplayEnded()) {
            return $this->getType();
        }
        return self::TYPE_INFO;
    }


    protected function isVisible(): bool
    {
        if ($this->isPermanent()) {
            return true;
        }
        $hasEventStarted = $this->hasEventStarted();
        $hasDisplayStarted = $this->hasDisplayStarted();
        $hasEventEnded = !$this->hasEventEnded();
        $hasDisplayEnded = !$this->hasDisplayEnded();

        return ($hasEventStarted || $hasDisplayStarted)
            && ($hasEventEnded || $hasDisplayEnded);
    }

    public function isVisibleForUser(ilObjUser $ilObjUser): bool
    {
        if ($ilObjUser->getId() === 0 && $this->interruptive) {
            return false;
        }
        if (!$this->isVisible()) {
            return false;
        }
        if ($this->hasUserDismissed($ilObjUser)) {
            return false;
        }
        return ($this->isVisibleToUserBasedOnLanguage($ilObjUser) && $this->isVisibleRoleUserRoles($ilObjUser));
    }


    protected function isVisibleToUserBasedOnLanguage(ilObjUser $ilObjUser): bool
    {
        if (!$this->hasLanguageLimitation()) {
            return true;
        }

        return in_array($ilObjUser->getLanguage(), $this->getLimitedToLanguages(), true);
    }


    protected function isVisibleRoleUserRoles(ilObjUser $ilObjUser): bool
    {
        if (!$this->isLimitToRoles()) {
            return true;
        }
        global $DIC;

        if ($ilObjUser->getId() === 0 && in_array(0, $this->getLimitedToRoleIds())) {
            return true;
        }

        return $DIC->rbac()->review()->isAssignedToAtLeastOneGivenRole(
            $ilObjUser->getId(),
            $this->getLimitedToRoleIds()
        );
    }

    protected ?int $id = null;
    protected string $title = '';
    protected string $body = '';
    protected ?\DateTimeImmutable $event_start = null;
    protected ?\DateTimeImmutable $event_end = null;
    protected ?\DateTimeImmutable $display_start = null;
    protected ?\DateTimeImmutable $display_end = null;
    protected int $type = self::TYPE_INFO;
    protected int $type_during_event = self::TYPE_ERROR;
    protected bool $dismissable = true;
    protected bool $permanent = true;
    protected array $allowed_users = [0, 6, 13];
    protected ?int $parent_id = null;
    protected ?\DateTimeImmutable $create_date = null;
    protected \DateTimeImmutable $last_update;
    protected ?int $created_by = null;
    protected ?int $last_update_by = null;
    protected bool $active = true;
    protected array $limited_to_languages = [];
    protected bool $has_language_limitation = false;
    protected array $limited_to_role_ids = [];
    protected bool $limit_to_roles = false;
    protected bool $interruptive = false;
    protected string $link = '';
    protected int $link_type = self::LINK_TYPE_NONE;
    protected string $link_target = '_top';

    public function wakeUp($field_name, $field_value)
    {
        switch ($field_name) {
            case 'event_start':
            case 'event_end':
            case 'display_end':
            case 'display_start':
            case 'create_date':
            case 'last_update':
                return (new DateTimeImmutable())->setTimestamp((int) $field_value);

            case 'allowed_users':
                if ($field_value === null) {
                    $array_unique = self::$allowed_user_ids;
                } else {
                    $json_decode = json_decode((string) $field_value, true);
                    if (!is_array($json_decode)) {
                        $json_decode = self::$allowed_user_ids;
                    }
                    $array_unique = array_unique($json_decode);
                }

                sort($array_unique);

                return $array_unique;
            case 'limited_to_languages':
            case 'limited_to_role_ids':
                return json_decode((string) $field_value, true);
        }
        return null;
    }

    public function sleep($field_name)
    {
        switch ($field_name) {
            case 'event_start':
            case 'event_end':
            case 'display_end':
            case 'display_start':
            case 'create_date':
            case 'last_update':
                $datetime = $this->{$field_name} ?? new DateTimeImmutable();
                return $datetime->getTimestamp();
            case 'allowed_users':
                $allowed_users = self::$allowed_user_ids;
                foreach ($this->allowed_users as $user_id) {
                    $allowed_users[] = (int) $user_id;
                }

                return json_encode(array_unique($allowed_users), JSON_THROW_ON_ERROR);
            case 'limited_to_languages':
            case 'limited_to_role_ids':
                return json_encode($this->{$field_name}, JSON_THROW_ON_ERROR);
        }
        return null;
    }

    #[\Override]
    public function create(): void
    {
        global $DIC;
        $this->setCreateDate(new DateTimeImmutable());
        $this->setCreatedBy($DIC->user()->getId());
        parent::create();
    }

    public function setBody(string $body): void
    {
        $this->body = $body;
    }

    public function getBody(): string
    {
        return $this->body;
    }

    public function setDisplayEnd(DateTimeImmutable $display_end): void
    {
        $this->display_end = $display_end;
    }

    public function getDisplayEnd(): DateTimeImmutable
    {
        return $this->display_end ?? new DateTimeImmutable();
    }

    public function setDisplayStart(DateTimeImmutable $display_start): void
    {
        $this->display_start = $display_start;
    }

    public function getDisplayStart(): DateTimeImmutable
    {
        return $this->display_start ?? new DateTimeImmutable();
    }

    public function setEventEnd(DateTimeImmutable $event_end): void
    {
        $this->event_end = $event_end;
    }

    public function getEventEnd(): DateTimeImmutable
    {
        return $this->event_end ?? new DateTimeImmutable();
    }

    public function setEventStart(DateTimeImmutable $event_start): void
    {
        $this->event_start = $event_start;
    }

    public function getEventStart(): DateTimeImmutable
    {
        return $this->event_start ?? new DateTimeImmutable();
    }

    public function setId(int $id): void
    {
        $this->id = $id;
    }

    public function getId(): int
    {
        return (int) $this->id;
    }

    public function setTitle(string $title): void
    {
        $this->title = $title;
    }

    public function getTitle(): string
    {
        return $this->title;
    }

    public function setType(int $type): void
    {
        $this->type = $type;
    }

    public function getType(): int
    {
        return $this->type;
    }

    public function setTypeDuringEvent(int $type_during_event): void
    {
        $this->type_during_event = $type_during_event;
    }

    public function getTypeDuringEvent(): int
    {
        return in_array(
            $this->type_during_event,
            [self::TYPE_WARNING, self::TYPE_ERROR, self::TYPE_INFO]
        ) ? $this->type_during_event : self::TYPE_INFO;
    }

    public function setDismissable(bool $dismissable): void
    {
        $this->dismissable = $dismissable;
    }

    public function getDismissable(): bool
    {
        return $this->dismissable;
    }

    protected function hasEventStarted(): bool
    {
        return $this->getTime() > $this->getEventStart();
    }

    protected function hasDisplayStarted(): bool
    {
        return $this->getTime() > $this->getDisplayStart();
    }

    protected function hasEventEnded(): bool
    {
        return $this->getTime() > $this->getEventEnd();
    }

    protected function hasDisplayEnded(): bool
    {
        return $this->getTime() > $this->getDisplayEnd();
    }

    public function setPermanent(bool $permanent): void
    {
        $this->permanent = $permanent;
    }

    public function isPermanent(): bool
    {
        return $this->permanent;
    }

    public function isDuringEvent(): bool
    {
        return $this->hasEventStarted() && !$this->hasEventEnded();
    }

    public function setCreateDate(DateTimeImmutable $create_date): void
    {
        $this->create_date = $create_date;
    }

    public function getCreateDate(): DateTimeImmutable
    {
        return $this->create_date ?? new DateTimeImmutable();
    }

    public function setCreatedBy(int $created_by): void
    {
        $this->created_by = $created_by;
    }

    public function getCreatedBy(): int
    {
        return (int) $this->created_by;
    }

    protected function getTime(): DateTimeImmutable
    {
        return new DateTimeImmutable();
    }

    public function isActive(): bool
    {
        return $this->active;
    }

    public function setActive(bool $active): void
    {
        $this->active = $active;
    }

    public function getLimitedToLanguages(): array
    {
        return $this->limited_to_languages;
    }

    public function setLimitedToLanguages(array $limited_to_languages): void
    {
        $this->limited_to_languages = $limited_to_languages;
    }

    public function hasLanguageLimitation(): bool
    {
        return $this->has_language_limitation;
    }

    public function setHasLanguageLimitation(bool $has_language_limitation): void
    {
        $this->has_language_limitation = $has_language_limitation;
    }

    public function getLimitedToRoleIds(): array
    {
        return $this->limited_to_role_ids;
    }

    public function setLimitedToRoleIds(array $limited_to_role_ids): void
    {
        $this->limited_to_role_ids = $limited_to_role_ids;
    }

    public function isLimitToRoles(): bool
    {
        return $this->limit_to_roles;
    }

    public function setLimitToRoles(bool $limit_to_roles): void
    {
        $this->limit_to_roles = $limit_to_roles;
    }
}