NotificationsService.php

Go to the documentation of this file.

<?php
namespace Elgg\Notifications;

use ElggEntity;

class NotificationsService {

    const QUEUE_NAME = 'notifications';

    protected $subscriptions;

    protected $queue;

    protected $hooks;

    protected $session;

    protected $events = array();

    protected $methods = array();

    protected $deprHandlers = array();

    protected $deprSubjects = array();

    public function __construct(\Elgg\Notifications\SubscriptionsService $subscriptions,
            \Elgg\Queue\Queue $queue, \Elgg\PluginHooksService $hooks, \ElggSession $session) {
        $this->subscriptions = $subscriptions;
        $this->queue = $queue;
        $this->hooks = $hooks;
        $this->session = $session;
    }

    public function registerEvent($type, $subtype, array $actions = array()) {

        if (!isset($this->events[$type])) {
            $this->events[$type] = array();
        }
        if (!isset($this->events[$type][$subtype])) {
            $this->events[$type][$subtype] = array();
        }

        $action_list =& $this->events[$type][$subtype];
        if ($actions) {
            $action_list = array_unique(array_merge($action_list, $actions));
        } elseif (!in_array('create', $action_list)) {
            $action_list[] = 'create';
        }
    }

    public function unregisterEvent($type, $subtype) {

        if (!isset($this->events[$type]) || !isset($this->events[$type][$subtype])) {
            return false;
        }

        unset($this->events[$type][$subtype]);

        return true;
    }

    public function getEvents() {
        return $this->events;
    }

    public function registerMethod($name) {
        $this->methods[$name] = $name;
    }

    public function unregisterMethod($name) {
        if (isset($this->methods[$name])) {
            unset($this->methods[$name]);
            return true;
        }
        return false;
    }

    public function getMethods() {
        return $this->methods;
    }

    public function enqueueEvent($action, $type, $object) {
        if ($object instanceof \ElggData) {
            $object_type = $object->getType();
            $object_subtype = $object->getSubtype();

            $registered = false;
            if (isset($this->events[$object_type])
                && isset($this->events[$object_type][$object_subtype])
                && in_array($action, $this->events[$object_type][$object_subtype])) {
                $registered = true;
            }

            if ($registered) {
                $params = array(
                    'action' => $action,
                    'object' => $object,
                );
                $registered = $this->hooks->trigger('enqueue', 'notification', $params, $registered);
            }

            if ($registered) {
                $this->queue->enqueue(new \Elgg\Notifications\Event($object, $action));
            }
        }
    }

    public function processQueue($stopTime) {

        $this->subscriptions->methods = $this->methods;

        $count = 0;

        // @todo grab mutex
        
        $ia = $this->session->setIgnoreAccess(true);

        while (time() < $stopTime) {
            // dequeue notification event
            $event = $this->queue->dequeue();
            if (!$event) {
                break;
            }

            // test for usage of the deprecated override hook
            if ($this->existsDeprecatedNotificationOverride($event)) {
                continue;
            }

            $subscriptions = $this->subscriptions->getSubscriptions($event);

            // return false to stop the default notification sender
            $params = array('event' => $event, 'subscriptions' => $subscriptions);
            if ($this->hooks->trigger('send:before', 'notifications', $params, true)) {
                $this->sendNotifications($event, $subscriptions);
            }
            $this->hooks->trigger('send:after', 'notifications', $params);
            $count++;
        }

        // release mutex

        $this->session->setIgnoreAccess($ia);

        return $count;
    }

    protected function sendNotifications($event, $subscriptions) {

        if (!$this->methods) {
            return 0;
        }

        $count = 0;
        foreach ($subscriptions as $guid => $methods) {
            foreach ($methods as $method) {
                if (in_array($method, $this->methods)) {
                    if ($this->sendNotification($event, $guid, $method)) {
                        $count++;
                    }
                }
            }
        }
        return $count;
    }

    protected function sendNotification(\Elgg\Notifications\Event $event, $guid, $method) {

        $recipient = get_user($guid);
        if (!$recipient || $recipient->isBanned()) {
            return false;
        }

        // don't notify the creator of the content
        if ($recipient->getGUID() == $event->getActorGUID()) {
            return false;
        }

        $actor = $event->getActor();
        $object = $event->getObject();
        if (!$actor || !$object) {
            return false;
        }

        if (($object instanceof ElggEntity) && !has_access_to_entity($object, $recipient)) {
            return false;
        }

        $language = $recipient->language;
        $params = array(
            'event' => $event,
            'method' => $method,
            'recipient' => $recipient,
            'language' => $language,
            'object' => $object,
        );

        $subject = _elgg_services()->translator->translate('notification:subject', array($actor->name), $language);
        $body = _elgg_services()->translator->translate('notification:body', array($object->getURL()), $language);
        $notification = new \Elgg\Notifications\Notification($event->getActor(), $recipient, $language, $subject, $body, '', $params);

        $type = 'notification:' . $event->getDescription();
        if ($this->hooks->hasHandler('prepare', $type)) {
            $notification = $this->hooks->trigger('prepare', $type, $params, $notification);
        } else {
            // pre Elgg 1.9 notification message generation
            $notification = $this->getDeprecatedNotificationBody($notification, $event, $method);
        }

        if ($this->hooks->hasHandler('send', "notification:$method")) {
            // return true to indicate the notification has been sent
            $params = array(
                'notification' => $notification,
                'event' => $event,
            );
            return $this->hooks->trigger('send', "notification:$method", $params, false);
        } else {
            // pre Elgg 1.9 notification handler
            $userGuid = $notification->getRecipientGUID();
            $senderGuid = $notification->getSenderGUID();
            $subject = $notification->subject;
            $body = $notification->body;
            $params = $notification->params;
            return (bool)_elgg_notify_user($userGuid, $senderGuid, $subject, $body, $params, array($method));
        }
    }

    public function registerDeprecatedHandler($method, $handler) {
        $this->deprHandlers[$method] = $handler;
    }

    public function getDeprecatedHandler($method) {
        if (isset($this->deprHandlers[$method])) {
            return $this->deprHandlers[$method];
        } else {
            return null;
        }
    }

    public function getMethodsAsDeprecatedGlobal() {
        $data = array();
        foreach ($this->methods as $method) {
            $data[$method] = 'empty';
        }
        return $data;
    }

    protected function getDeprecatedNotificationBody(\Elgg\Notifications\Notification $notification, \Elgg\Notifications\Event $event, $method) {
        $entity = $event->getObject();
        $params = array(
            'entity' => $entity,
            'to_entity' => $notification->getRecipient(),
            'method' => $method,
        );
        $subject = $this->getDeprecatedNotificationSubject($entity->getType(), $entity->getSubtype());
        $string = $subject . ": " . $entity->getURL();
        $body = $this->hooks->trigger('notify:entity:message', $entity->getType(), $params, $string);

        if ($subject) {
            $notification->subject = $subject;
            $notification->body = $body;
        }

        return $notification;
    }

    public function setDeprecatedNotificationSubject($type, $subtype, $subject) {
        if ($type == '') {
            $type = '__BLANK__';
        }
        if ($subtype == '') {
            $subtype = '__BLANK__';
        }

        if (!isset($this->deprSubjects[$type])) {
            $this->deprSubjects[$type] = array();
        }

        $this->deprSubjects[$type][$subtype] = $subject;
    }

    protected function getDeprecatedNotificationSubject($type, $subtype) {
        if ($type == '') {
            $type = '__BLANK__';
        }
        if ($subtype == '') {
            $subtype = '__BLANK__';
        }

        if (!isset($this->deprSubjects[$type])) {
            return '';
        }

        if (!isset($this->deprSubjects[$type][$subtype])) {
            return '';
        }

        return $this->deprSubjects[$type][$subtype];
    }

    protected function existsDeprecatedNotificationOverride(\Elgg\Notifications\Event $event) {
        $entity = $event->getObject();
        if (!elgg_instanceof($entity)) {
            return false;
        }
        $params = array(
            'event' => $event->getAction(),
            'object_type' => $entity->getType(),
            'object' => $entity,
        );
        $hookresult = $this->hooks->trigger('object:notifications', $entity->getType(), $params, false);
        if ($hookresult === true) {
            elgg_deprecated_notice("Using the plugin hook 'object:notifications' has been deprecated by the hook 'send:before', 'notifications'", 1.9);
            return true;
        } else {
            return false;
        }
    }
}