notification.php

Go to the documentation of this file.

<?php

use Elgg\Mail\Address;
use Zend\Mail\Message;

function elgg_register_notification_event($object_type, $object_subtype, array $actions = array()) {
    _elgg_services()->notifications->registerEvent($object_type, $object_subtype, $actions);
}

function elgg_unregister_notification_event($object_type, $object_subtype) {
    return _elgg_services()->notifications->unregisterEvent($object_type, $object_subtype);
}

function elgg_register_notification_method($name) {
    _elgg_services()->notifications->registerMethod($name);
}

function elgg_get_notification_methods() {
    return _elgg_services()->notifications->getMethods();
}

function elgg_unregister_notification_method($name) {
    return _elgg_services()->notifications->unregisterMethod($name);
}

function elgg_add_subscription($user_guid, $method, $target_guid) {
    $methods = _elgg_services()->notifications->getMethods();
    $db = _elgg_services()->db;
    $subs = new \Elgg\Notifications\SubscriptionsService($db, $methods);
    return $subs->addSubscription($user_guid, $method, $target_guid);
}

function elgg_remove_subscription($user_guid, $method, $target_guid) {
    $methods = _elgg_services()->notifications->getMethods();
    $db = _elgg_services()->db;
    $subs = new \Elgg\Notifications\SubscriptionsService($db, $methods);
    return $subs->removeSubscription($user_guid, $method, $target_guid);
}

function elgg_get_subscriptions_for_container($container_guid) {
    $methods = _elgg_services()->notifications->getMethods();
    $db = _elgg_services()->db;
    $subs = new \Elgg\Notifications\SubscriptionsService($db, $methods);
    return $subs->getSubscriptionsForContainer($container_guid);
}

function _elgg_enqueue_notification_event($action, $type, $object) {
    _elgg_services()->notifications->enqueueEvent($action, $type, $object);
}

function _elgg_notifications_cron() {
    // calculate when we should stop
    // @todo make configurable?
    $stop_time = time() + 45;
    _elgg_services()->notifications->processQueue($stop_time);
}

function _elgg_send_email_notification($hook, $type, $result, $params) {
    
    if ($result === true) {
        // assume someone else already sent the message
        return;
    }
    
    /* @var \Elgg\Notifications\Notification $message */
    $message = $params['notification'];

    $sender = $message->getSender();
    $recipient = $message->getRecipient();

    if (!$sender) {
        return false;
    }

    if (!$recipient || !$recipient->email) {
        return false;
    }

    $to = $recipient->email;

    $site = elgg_get_site_entity();
    // If there's an email address, use it - but only if it's not from a user.
    if (!($sender instanceof \ElggUser) && $sender->email) {
        $from = $sender->email;
    } else if ($site->email) {
        $from = $site->email;
    } else {
        // If all else fails, use the domain of the site.
        $token = _elgg_services()->crypto->getRandomBytes(24);
        $from = "noreply-{$token}@{$site->getDomain()}";
    }

    return elgg_send_email($from, $to, $message->subject, $message->body, $params);
}

function _elgg_notifications_smtp_default_message_id_header($hook, $type, $returnvalue, $params) {
    
    if (!is_array($returnvalue) || !is_array($returnvalue['params'])) {
        // another hook handler returned a non-array, let's not override it
        return;
    }
    
    $hostname = parse_url(elgg_get_site_url(), PHP_URL_HOST);
    $url_path = parse_url(elgg_get_site_url(), PHP_URL_PATH);
    
    $mt = microtime(true);
    
    $returnvalue['headers']['Message-ID'] = "{$url_path}.default.{$mt}@{$hostname}";
    
    return $returnvalue;
}
function _elgg_notifications_smtp_thread_headers($hook, $type, $returnvalue, $params) {

    if (!is_array($returnvalue) || !is_array($returnvalue['params'])) {
        // another hook handler returned a non-array, let's not override it
        return;
    }

    $notificationParams = elgg_extract('params', $returnvalue, array());
    $notification = elgg_extract('notification', $notificationParams);

    if (!($notification instanceof \Elgg\Notifications\Notification)) {
        return $returnvalue;
    }

    $hostname = parse_url(elgg_get_site_url(), PHP_URL_HOST);
    $urlPath = parse_url(elgg_get_site_url(), PHP_URL_PATH);

    $object = elgg_extract('object', $notification->params);
    $event = elgg_extract('event', $notification->params);

    if (($object instanceof \ElggEntity) && ($event instanceof \Elgg\Notifications\NotificationEvent)) {
        if ($event->getAction() === 'create') {
            // create event happens once per entity and we need to guarantee message id uniqueness
            // and at the same time have thread message id that we don't need to store
            $messageId = "{$urlPath}.entity.{$object->guid}@{$hostname}";
        } else {
            $mt = microtime(true);
            $messageId = "{$urlPath}.entity.{$object->guid}.$mt@{$hostname}";
        }
        $returnvalue['headers']["Message-ID"] = $messageId;
        $container = $object->getContainerEntity();

        // let's just thread comments by default
        if (($container instanceof \ElggEntity) && ($object instanceof \ElggComment)) {

            $threadMessageId = "<{$urlPath}.entity.{$container->guid}@{$hostname}>";
            $returnvalue['headers']['In-Reply-To'] = $threadMessageId;
            $returnvalue['headers']['References'] = $threadMessageId;
        }
    }

    return $returnvalue;
}

function _elgg_notifications_init() {
    elgg_register_plugin_hook_handler('cron', 'minute', '_elgg_notifications_cron', 100);
    elgg_register_event_handler('all', 'all', '_elgg_enqueue_notification_event', 700);

    // add email notifications
    elgg_register_notification_method('email');
    elgg_register_plugin_hook_handler('send', 'notification:email', '_elgg_send_email_notification');
    elgg_register_plugin_hook_handler('email', 'system', '_elgg_notifications_smtp_default_message_id_header', 1);
    elgg_register_plugin_hook_handler('email', 'system', '_elgg_notifications_smtp_thread_headers');

    // add ability to set personal notification method
    elgg_extend_view('forms/account/settings', 'core/settings/account/notifications');
    elgg_register_plugin_hook_handler('usersettings:save', 'user', '_elgg_save_notification_user_settings');
}

function _elgg_notify_user($to, $from, $subject, $message, array $params = null, $methods_override = "") {

    $notify_service = _elgg_services()->notifications;

    // Sanitise
    if (!is_array($to)) {
        $to = array((int) $to);
    }
    $from = (int) $from;
    //$subject = sanitise_string($subject);
    // Get notification methods
    if (($methods_override) && (!is_array($methods_override))) {
        $methods_override = array($methods_override);
    }

    $result = array();

    foreach ($to as $guid) {
        // Results for a user are...
        $result[$guid] = array();

        if ($guid) { // Is the guid > 0?
            // Are we overriding delivery?
            $methods = $methods_override;
            if (!$methods) {
                $tmp = get_user_notification_settings($guid);
                $methods = array();
                // $tmp may be false. don't cast
                if (is_object($tmp)) {
                    foreach ($tmp as $k => $v) {
                        // Add method if method is turned on for user!
                        if ($v) {
                            $methods[] = $k;
                        }
                    }
                }
            }

            if ($methods) {
                // Deliver
                foreach ($methods as $method) {

                    $handler = $notify_service->getDeprecatedHandler($method);
                    /* @var callable $handler */
                    if (!$handler || !is_callable($handler)) {
                        elgg_log("No handler registered for the method $method", 'WARNING');
                        continue;
                    }

                    elgg_log("Sending message to $guid using $method");

                    // Trigger handler and retrieve result.
                    try {
                        $result[$guid][$method] = call_user_func(
                            $handler,
                            $from ? get_entity($from) : null,
                            get_entity($guid),
                            $subject,
                            $message,
                            $params
                        );
                    } catch (Exception $e) {
                        error_log($e->getMessage());
                    }
                }
            }
        }
    }

    return $result;
}

function notify_user($to, $from = 0, $subject = '', $message = '', array $params = array(), $methods_override = null) {

    $params['subject'] = $subject;
    $params['body'] = $message;
    $params['methods_override'] = $methods_override;

    if ($from) {
        $sender = get_entity($from);
    } else {
        $sender = elgg_get_site_entity();
    }
    if (!$sender) {
        return [];
    }

    $recipients = [];
    $to = (array) $to;
    foreach ($to as $guid) {
        $recipient = get_entity($guid);
        if (!$recipient) {
            continue;
        }
        $recipients[] = $recipient;
    }

    return _elgg_services()->notifications->sendInstantNotifications($sender, $recipients, $params);
}

function get_user_notification_settings($user_guid = 0) {

    elgg_deprecated_notice(__FUNCTION__ . ' has been deprecated by ElggUser::getNotificationSettings()', '2.3');

    if ((int) $user_guid == 0) {
        $user_guid = elgg_get_logged_in_user_guid();
    }

    $user = get_entity($user_guid);
    if (!$user instanceof \ElggUser) {
        return false;
    }

    return (object) $user->getNotificationSettings();
}

function set_user_notification_setting($user_guid, $method, $value) {
    elgg_deprecated_notice(__FUNCTION__ . ' has been deprecated by ElggUser::setNotificationSetting()', '2.3');

    if (!$user_guid) {
        $user_guid = elgg_get_logged_in_user_guid();
    }
    $user = get_entity($user_guid);
    if (!$user instanceof \ElggUser) {
        return false;
    }

    if (is_string($value)) {
        $value = strtolower($value);
    }
    if ($value == 'yes' || $value == 'on' || $value == 'enabled') {
        $value = true;
    } else if ($value == 'no' || $value == 'off' || $value == 'disabled') {
        $value = false;
    }

    return $user->setNotificationSetting($method, (bool) $value);
}

function elgg_send_email($from, $to, $subject, $body, array $params = null) {
    if (!$from) {
        $msg = "Missing a required parameter, '" . 'from' . "'";
        throw new \NotificationException($msg);
    }

    if (!$to) {
        $msg = "Missing a required parameter, '" . 'to' . "'";
        throw new \NotificationException($msg);
    }

    $headers = array(
        "Content-Type" => "text/plain; charset=UTF-8; format=flowed",
        "MIME-Version" => "1.0",
        "Content-Transfer-Encoding" => "8bit",
    );

    // return true/false to stop elgg_send_email() from sending
    $mail_params = array(
        'to' => $to,
        'from' => $from,
        'subject' => $subject,
        'body' => $body,
        'headers' => $headers,
        'params' => $params,
    );

    // $mail_params is passed as both params and return value. The former is for backwards
    // compatibility. The latter is so handlers can now alter the contents/headers of
    // the email by returning the array
    $result = _elgg_services()->hooks->trigger('email', 'system', $mail_params, $mail_params);
    if (!is_array($result)) {
        // don't need null check: Handlers can't set a hook value to null!
        return (bool) $result;
    }

    // strip name from to and from

    $to_address = Address::fromString($result['to']);
    $from_address = Address::fromString($result['from']);


    $subject = elgg_strip_tags($result['subject']);
    $subject = html_entity_decode($subject, ENT_QUOTES, 'UTF-8');
    // Sanitise subject by stripping line endings
    $subject = preg_replace("/(\r\n|\r|\n)/", " ", $subject);
    $subject = trim($subject);

    $body = elgg_strip_tags($result['body']);
    $body = html_entity_decode($body, ENT_QUOTES, 'UTF-8');
    $body = wordwrap($body);

    $message = new Message();
    $message->setEncoding('UTF-8');
    $message->addFrom($from_address);
    $message->addTo($to_address);
    $message->setSubject($subject);
    $message->setBody($body);

    foreach ($result['headers'] as $headerName => $headerValue) {
        // Create a headerline in the format 'name: value'
        // This is done to force correct class detection for each header type
        // which influences the output of the header in the message
        $message->getHeaders()->addHeaderLine("{$headerName}: {$headerValue}");
    }

    try {
        _elgg_services()->mailer->send($message);
    } catch (\Zend\Mail\Exception\RuntimeException $e) {
        _elgg_services()->logger->error($e->getMessage());
        return false;
    }

    return true;
}

function _elgg_save_notification_user_settings() {

    $user = elgg_get_logged_in_user_entity();
    if (!$user) {
        return;
    }

    $method = get_input('method');

    $current_settings = $user->getNotificationSettings();

    $result = false;
    foreach ($method as $k => $v) {
        // check if setting has changed and skip if not
        if ($current_settings[$k] == ($v == 'yes')) {
            continue;
        }

        $result = $user->setNotificationSetting($k, ($v == 'yes'));
        if (!$result) {
            register_error(elgg_echo('notifications:usersettings:save:fail'));
        }
    }

    if ($result) {
        system_message(elgg_echo('notifications:usersettings:save:ok'));
    }
}

function _elgg_notifications_test($hook, $type, $tests) {
    global $CONFIG;
    $tests[] = "{$CONFIG->path}engine/tests/ElggCoreDatabaseQueueTest.php";
    return $tests;
}

return function(\Elgg\EventsService $events, \Elgg\HooksRegistrationService $hooks) {
    $events->registerHandler('init', 'system', '_elgg_notifications_init');

    $hooks->registerHandler('unit_test', 'system', '_elgg_notifications_test');
};