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) {
            $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(new SubscriptionNotificationEvent($object, $action, $actor));
    }
    
    protected function getNotificationHandler(NotificationEvent $event): 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);
    }
 
    public function processQueue($stopTime, $matrix = false) {
        
        return elgg_call(ELGG_IGNORE_ACCESS, function() use ($stopTime, $matrix) {
            $delivery_matrix = [];
            
            $count = 0;
            
            while (time() < $stopTime) {
                // dequeue notification event
                $event = $this->queue->dequeue();
                /* @var $event NotificationEvent */
                
                if (!$event) {
                    // queue is empty
                    break;
                }
                
                if (!$event instanceof NotificationEvent || !$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);
                
                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 = []) {
        if (empty($this->methods)) {
            return [];
        }
        
        $params['recipients'] = array_filter($recipients, function($e) {
            return ($e instanceof \ElggUser);
        });
        
        $object = elgg_extract('object', $params);
        $action = elgg_extract('action', $params);
        
        $event = new InstantNotificationEvent($object, $action, $sender);
        
        $handler = new InstantNotificationEventHandler($event, $this, $params);
        
        return $handler->send();
    }
}