NotificationsService.php

Go to the documentation of this file.

<?php
 
namespace Elgg\Notifications;
 
use Elgg\EventsService;
use Elgg\Exceptions\InvalidArgumentException;
use Elgg\Queue\Queue;
use Elgg\Traits\Loggable;
 
class NotificationsService {
 
    use Loggable;
    
    protected array $events = [];
 
    protected array $methods = [];
 
    public function __construct(
            protected Queue $queue,
            protected \ElggSession $session,
            protected EventsService $elgg_events
    ) {
    }
 
    public function registerEvent(string $type, string $subtype, string $action = 'create', string $handler = NotificationEventHandler::class): void {
        if (!is_a($handler, NotificationEventHandler::class, true)) {
            throw new InvalidArgumentException('$handler needs to be a ' . NotificationEventHandler::class . ' classname');
        }
        
        if (!isset($this->events[$type])) {
            $this->events[$type] = [];
        }
        
        if (!isset($this->events[$type][$subtype])) {
            $this->events[$type][$subtype] = [];
        }
        
        if (!isset($this->events[$type][$subtype][$action])) {
            $this->events[$type][$subtype][$action] = [];
        }
        
        if (in_array($handler, $this->events[$type][$subtype][$action])) {
            return;
        }
        
        $this->events[$type][$subtype][$action][] = $handler;
    }
 
    public function unregisterEvent(string $type, string $subtype, string $action = 'create', string $handler = NotificationEventHandler::class): void {
        if (!isset($this->events[$type][$subtype][$action])) {
            return;
        }
        
        $key = array_search($handler, $this->events[$type][$subtype][$action]);
        if ($key !== false) {
            unset($this->events[$type][$subtype][$action][$key]);
        }
        
        if (empty($this->events[$type][$subtype][$action])) {
            unset($this->events[$type][$subtype][$action]);
        }
        
        if (empty($this->events[$type][$subtype])) {
            unset($this->events[$type][$subtype]);
        }
        
        if (empty($this->events[$type])) {
            unset($this->events[$type]);
        }
    }
 
    public function getEvents(): array {
        return $this->events;
    }
 
    public function registerMethod(string $name): void {
        $this->methods[$name] = $name;
    }
 
    public function unregisterMethod(string $name): void {
        if (!$this->isRegisteredMethod($name)) {
            return;
        }
        
        unset($this->methods[$name]);
    }
 
    public function getMethods(): array {
        return $this->methods;
    }
    
    public function isRegisteredMethod(string $method): bool {
        return in_array($method, $this->methods);
    }
 
    public function enqueueEvent(string $action, \ElggData $object, ?\ElggEntity $actor = null): void {
        $object_type = $object->getType();
        $object_subtype = $object->getSubtype();
        $actor = $actor ?? elgg_get_logged_in_user_entity(); // default to logged in user
        if (!isset($actor) && ($object instanceof \ElggEntity || $object instanceof \ElggExtender)) {
            // still not set, default to the owner of $object
            $actor = $object->getOwnerEntity() ?: null;
        }
        
        $handlers = $this->getSubscriptionHandlers($object_type, $object_subtype, $action);
        if (empty($handlers)) {
            return;
        }
        
        $params = [
            'action' => $action,
            'object' => $object,
            'actor' => $actor,
        ];
        $registered = (bool) $this->elgg_events->triggerResults('enqueue', 'notification', $params, true);
        if (!$registered) {
            return;
        }
        
        $this->elgg_events->trigger('enqueue', 'notifications', $object);
        $this->queue->enqueue(new SubscriptionNotificationEvent($object, $action, $actor));
    }
    
    protected function getSubscriptionHandlers(string $type, string $subtype, string $action): array {
        if (!isset($this->events[$type][$subtype][$action])) {
            return [];
        }
        
        $result = [];
        foreach ($this->events[$type][$subtype][$action] as $handler) {
            if (is_a($handler, InstantNotificationEventHandler::class, true)) {
                continue;
            }
            
            $result[] = $handler;
        }
        
        return $result;
    }
    
    protected function getInstantHandlers(string $type, string $subtype, string $action): array {
        if (!isset($this->events[$type][$subtype][$action])) {
            return [
                InstantNotificationEventHandler::class,
            ];
        }
        
        $result = [];
        foreach ($this->events[$type][$subtype][$action] as $handler) {
            if (!is_a($handler, InstantNotificationEventHandler::class, true)) {
                continue;
            }
            
            $result[] = $handler;
        }
        
        if (empty($result)) {
            return [
                InstantNotificationEventHandler::class,
            ];
        }
        
        return $result;
    }
 
    public function processQueue(int $stopTime): int {
        return elgg_call(ELGG_IGNORE_ACCESS, function() use ($stopTime) {
            $count = 0;
            
            while (time() < $stopTime) {
                // dequeue notification event
                $event = elgg_call(ELGG_SHOW_DISABLED_ENTITIES, function () {
                    // showing disabled entities for deserialization
                    return $this->queue->dequeue();
                });
                
                if (!$event instanceof NotificationEvent) {
                    // queue is empty
                    break;
                }
                
                $object = $event->getObject();
                if (!$object instanceof \ElggData || !$event->getActor()) {
                    // event object or actor have been deleted since the event was enqueued
                    continue;
                }
                
                $this->elgg_events->trigger('dequeue', 'notifications', $object);
                
                $handlers = $this->getSubscriptionHandlers($object->getType(), $object->getSubtype(), $event->getAction());
                if (empty($handlers)) {
                    continue;
                }
                
                foreach ($handlers as $handler_class) {
                    $handler = new $handler_class($event, $this);
                    
                    try {
                        $handler->send();
                        $count++;
                    } catch (\Throwable $t) {
                        $this->getLogger()->error($t);
                    }
                }
            }
            
            return $count;
        });
    }
 
    public function sendInstantNotifications(\ElggEntity $sender, array $recipients = [], array $params = []): array {
        if (empty($this->methods)) {
            return [];
        }
        
        $object = elgg_extract('object', $params);
        $action = elgg_extract('action', $params);
        
        $event = new InstantNotificationEvent($object, $action, $sender);
        
        $handler = new InstantNotificationEventHandler($event, $this, $params);
        $handler->setRecipients($recipients);
        
        return $handler->send();
    }
    
    public function sendInstantNotification(\ElggUser $recipient, string $action, \ElggData $subject, array $params = [], ?\ElggEntity $from = null): array {
        if (empty($this->methods)) {
            return [];
        }
        
        $handlers = $this->getInstantHandlers($subject->getType(), $subject->getSubtype(), $action);
        if (empty($handlers)) {
            return [];
        }
        
        $from = $from ?? elgg_get_site_entity();
        
        $event = new InstantNotificationEvent($subject, $action, $from);
        
        $result = [];
        
        foreach ($handlers as $handler_class) {
            $handler = new $handler_class($event, $this, $params);
            $handler->setRecipients([$recipient]);
            
            try {
                $handler_result = $handler->send();
                
                $result = $result + $handler_result;
            } catch (\Throwable $t) {
                $this->getLogger()->error($t);
            }
        }
        
        return $result;
    }
}