NotificationsService.php

Go to the documentation of this file.

<?php
 
namespace Elgg\Notifications;
 
use Elgg\EventsService;
use Elgg\Exceptions\InvalidArgumentException;
use Elgg\Traits\Loggable;
use Elgg\Queue\Queue;
 
class NotificationsService {
 
    use Loggable;
    
    protected $queue;
 
    protected $elgg_events;
 
    protected $session;
    
    protected $events = [];
 
    protected $methods = [];
 
    public function __construct(
            Queue $queue,
            \ElggSession $session,
            EventsService $elgg_events
    ) {
 
        $this->queue = $queue;
        $this->session = $session;
        $this->elgg_events = $elgg_events;
    }
 
    public function registerEvent(string $type, string $subtype, array $actions = [], string $handler = NotificationEventHandler::class) {
        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 (empty($actions) && !array_key_exists('create', $this->events[$type][$subtype])) {
            $actions[] = 'create';
        }
        
        foreach ($actions as $action) {
            $this->events[$type][$subtype][$action] = $handler;
        }
    }
 
    public function unregisterEvent(string $type, string $subtype, array $actions = []): void {
 
        if (empty($actions)) {
            unset($this->events[$type][$subtype]);
        }
        
        foreach ($actions as $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 isRegisteredEvent(string $type, string $subtype, string $action): bool {
        return isset($this->events[$type][$subtype][$action]);
    }
 
    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;
        }
        
        $registered = $this->isRegisteredEvent($object_type, $object_subtype, $action);
        if (!$registered) {
            return;
        }
        
        $event = new SubscriptionNotificationEvent($object, $action, $actor);
        $handler = $this->getNotificationHandler($event);
        if ($handler instanceof InstantNotificationEventHandler) {
            // don't enqueue the instant handlers
            return;
        }
        
        $params = [
            'action' => $action,
            'object' => $object,
            'actor' => $actor,
        ];
        $registered = (bool) $this->elgg_events->triggerResults('enqueue', 'notification', $params, $registered);
        if (!$registered) {
            return;
        }
        
        $this->elgg_events->trigger('enqueue', 'notifications', $object);
        $this->queue->enqueue($event);
    }
    
    protected function getNotificationHandler(NotificationEvent $event, array $params = []): NotificationEventHandler {
        $object = $event->getObject();
        $handler = NotificationEventHandler::class;
        
        if (isset($this->events[$object->getType()][$object->getSubtype()][$event->getAction()])) {
            $handler = $this->events[$object->getType()][$object->getSubtype()][$event->getAction()];
        }
        
        return new $handler($event, $this, $params);
    }
 
    public function processQueue(int $stopTime, bool $matrix = false) {
        return elgg_call(ELGG_IGNORE_ACCESS, function() use ($stopTime, $matrix) {
            $delivery_matrix = [];
            
            $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;
                }
                
                if (!$event->getObject() || !$event->getActor()) {
                    // event object or actor have been deleted since the event was enqueued
                    continue;
                }
                
                $this->elgg_events->trigger('dequeue', 'notifications', $event->getObject());
                
                $handler = $this->getNotificationHandler($event);
                if ($handler instanceof InstantNotificationEventHandler) {
                    // this shouldn't happen
                    continue;
                }
                
                try {
                    $delivery_matrix[$event->getDescription()] = $handler->send();
                    $count++;
                } catch (\Throwable $t) {
                    $this->getLogger()->error($t);
                }
            }
            
            return $matrix ? $delivery_matrix : $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 [];
        }
        
        $from = $from ?? elgg_get_site_entity();
        
        $event = new InstantNotificationEvent($subject, $action, $from);
        
        $handler = $this->getNotificationHandler($event, $params);
        if (!$handler instanceof InstantNotificationEventHandler) {
            return [];
        }
        
        $handler->setRecipients([$recipient]);
        
        return $handler->send();
    }
}