Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00% covered (danger)
0.00%
0 / 1
45.16% covered (danger)
45.16%
14 / 31
CRAP
79.79% covered (warning)
79.79%
225 / 282
manager
0.00% covered (danger)
0.00%
0 / 1
45.16% covered (danger)
45.16%
14 / 31
193.32
79.79% covered (warning)
79.79%
225 / 282
 __construct
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
12 / 12
 load_notifications
0.00% covered (danger)
0.00%
0 / 1
3.33
66.67% covered (warning)
66.67%
4 / 6
 mark_notifications_read
0.00% covered (danger)
0.00%
0 / 1
2.00
0.00% covered (danger)
0.00%
0 / 2
 mark_notifications
0.00% covered (danger)
0.00%
0 / 1
4.84
62.50% covered (warning)
62.50%
5 / 8
 mark_notifications_read_by_parent
0.00% covered (danger)
0.00%
0 / 1
2.00
0.00% covered (danger)
0.00%
0 / 2
 mark_notifications_by_parent
0.00% covered (danger)
0.00%
0 / 1
3.04
83.33% covered (warning)
83.33%
5 / 6
 mark_notifications_by_id
0.00% covered (danger)
0.00%
0 / 1
12.00
0.00% covered (danger)
0.00%
0 / 4
 add_notifications
0.00% covered (danger)
0.00%
0 / 1
4
95.00% covered (success)
95.00%
19 / 20
 add_notifications_for_users
0.00% covered (danger)
0.00%
0 / 1
11.08
91.43% covered (success)
91.43%
32 / 35
 update_notifications
100.00% covered (success)
100.00%
1 / 1
3
100.00% covered (success)
100.00%
6 / 6
 update_notification
100.00% covered (success)
100.00%
1 / 1
3
100.00% covered (success)
100.00%
5 / 5
 delete_notifications
0.00% covered (danger)
0.00%
0 / 1
4.84
62.50% covered (warning)
62.50%
5 / 8
 get_subscription_types
100.00% covered (success)
100.00%
1 / 1
7
100.00% covered (success)
100.00%
17 / 17
 get_subscription_methods
0.00% covered (danger)
0.00%
0 / 1
6.00
0.00% covered (danger)
0.00%
0 / 7
 get_subscription_methods_instances
100.00% covered (success)
100.00%
1 / 1
3
100.00% covered (success)
100.00%
6 / 6
 get_available_subscription_methods
100.00% covered (success)
100.00%
1 / 1
3
100.00% covered (success)
100.00%
5 / 5
 get_user_notifications
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
8 / 8
 get_global_subscriptions
0.00% covered (danger)
0.00%
0 / 1
10.01
94.74% covered (success)
94.74%
18 / 19
 add_subscription
0.00% covered (danger)
0.00%
0 / 1
7.77
63.33% covered (warning)
63.33%
19 / 30
 delete_subscription
100.00% covered (success)
100.00%
1 / 1
5
100.00% covered (success)
100.00%
21 / 21
 disable_notifications
0.00% covered (danger)
0.00%
0 / 1
2.00
0.00% covered (danger)
0.00%
0 / 4
 purge_notifications
0.00% covered (danger)
0.00%
0 / 1
12.00
0.00% covered (danger)
0.00%
0 / 5
 enable_notifications
0.00% covered (danger)
0.00%
0 / 1
2.00
0.00% covered (danger)
0.00%
0 / 4
 prune_notifications
0.00% covered (danger)
0.00%
0 / 1
6.00
0.00% covered (danger)
0.00%
0 / 3
 get_default_methods
100.00% covered (success)
100.00%
1 / 1
4
100.00% covered (success)
100.00%
5 / 5
 get_item_type_class
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
3 / 3
 get_method_class
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 load_object
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
4 / 4
 get_notification_type_id
100.00% covered (success)
100.00%
1 / 1
5
100.00% covered (success)
100.00%
15 / 15
 get_notification_type_ids
0.00% covered (danger)
0.00%
0 / 1
3.04
83.33% covered (warning)
83.33%
5 / 6
 get_notified_users
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
5 / 5
<?php
/**
*
* This file is part of the phpBB Forum Software package.
*
* @copyright (c) phpBB Limited <https://www.phpbb.com>
* @license GNU General Public License, version 2 (GPL-2.0)
*
* For full copyright and license information, please see
* the docs/CREDITS.txt file.
*
*/
namespace phpbb\notification;
use Symfony\Component\DependencyInjection\ContainerInterface;
/**
* Notifications service class
*/
class manager
{
    /** @var array */
    protected $notification_types;
    /** @var array */
    protected $subscription_types;
    /** @var method\method_interface[] */
    protected $notification_methods;
    /** @var ContainerInterface */
    protected $phpbb_container;
    /** @var \phpbb\user_loader */
    protected $user_loader;
    /** @var \phpbb\event\dispatcher_interface */
    protected $phpbb_dispatcher;
    /** @var \phpbb\db\driver\driver_interface */
    protected $db;
    /** @var \phpbb\cache\service */
    protected $cache;
    /** @var \phpbb\language\language */
    protected $language;
    /** @var \phpbb\user */
    protected $user;
    /** @var string */
    protected $notification_types_table;
    /** @var string */
    protected $user_notifications_table;
    /**
    * Notification Constructor
    *
    * @param array $notification_types
    * @param array $notification_methods
    * @param ContainerInterface $phpbb_container
    * @param \phpbb\user_loader $user_loader
    * @param \phpbb\event\dispatcher_interface $phpbb_dispatcher
    * @param \phpbb\db\driver\driver_interface $db
    * @param \phpbb\cache\service $cache
    * @param \phpbb\language\language $language
    * @param \phpbb\user $user
    * @param string $notification_types_table
    * @param string $user_notifications_table
    *
    * @return \phpbb\notification\manager
    */
    public function __construct($notification_types, $notification_methods, ContainerInterface $phpbb_container, \phpbb\user_loader $user_loader, \phpbb\event\dispatcher_interface $phpbb_dispatcher, \phpbb\db\driver\driver_interface $db, \phpbb\cache\service $cache, \phpbb\language\language $language, \phpbb\user $user, $notification_types_table, $user_notifications_table)
    {
        $this->notification_types = $notification_types;
        $this->notification_methods = $notification_methods;
        $this->phpbb_container = $phpbb_container;
        $this->user_loader = $user_loader;
        $this->phpbb_dispatcher = $phpbb_dispatcher;
        $this->db = $db;
        $this->cache = $cache;
        $this->language = $language;
        $this->user = $user;
        $this->notification_types_table = $notification_types_table;
        $this->user_notifications_table = $user_notifications_table;
    }
    /**
    * Load the user's notifications for a given method
    *
    * @param string $method_name
    * @param array $options Optional options to control what notifications are loaded
    *                notification_id        Notification id to load (or array of notification ids)
    *                user_id                User id to load notifications for (Default: $user->data['user_id'])
    *                order_by            Order by (Default: notification_time)
    *                order_dir            Order direction (Default: DESC)
    *                 limit                Number of notifications to load (Default: 5)
    *                 start                Notifications offset (Default: 0)
    *                 all_unread            Load all unread notifications? If set to true, count_unread is set to true (Default: false)
    *                 count_unread        Count all unread notifications? (Default: false)
    *                 count_total            Count all notifications? (Default: false)
    * @return array Array of information based on the request with keys:
    *    'notifications'        array of notification type objects
    *    'unread_count'        number of unread notifications the user has if count_unread is true in the options
    *    'total_count'        number of notifications the user has if count_total is true in the options
    * @throws \phpbb\notification\exception when the method doesn't refer to a class extending \phpbb\notification\method\method_interface
    */
    public function load_notifications($method_name, array $options = array())
    {
        $method = $this->get_method_class($method_name);
        if (! $method instanceof \phpbb\notification\method\method_interface)
        {
            throw new \phpbb\notification\exception($this->language->lang('NOTIFICATION_METHOD_INVALID', $method_name));
        }
        else if ($method->is_available())
        {
            return $method->load_notifications($options);
        }
        else
        {
            return array(
                'notifications'        => array(),
                'unread_count'        => 0,
                'total_count'        => 0,
            );
        }
    }
    /**
     * Mark notifications read or unread for all available methods
     *
     * @param bool|string|array $notification_type_name Type identifier or array of item types (only acceptable if the $data is identical for the specified types). False to mark read for all item types
     * @param bool|int|array $item_id Item id or array of item ids. False to mark read for all item ids
     * @param bool|int|array $user_id User id or array of user ids. False to mark read for all user ids
     * @param bool|int $time Time at which to mark all notifications prior to as read. False to mark all as read. (Default: False)
     *
     * @deprecated since 3.2
     */
    public function mark_notifications_read($notification_type_name, $item_id, $user_id, $time = false)
    {
        $this->mark_notifications($notification_type_name, $item_id, $user_id, $time);
    }
    /**
    * Mark notifications read or unread for all available methods
    *
    * @param bool|string|array $notification_type_name Type identifier or array of item types (only acceptable if the $data is identical for the specified types). False to mark read for all item types
    * @param bool|int|array $item_id Item id or array of item ids. False to mark read for all item ids
    * @param bool|int|array $user_id User id or array of user ids. False to mark read for all user ids
    * @param bool|int $time Time at which to mark all notifications prior to as read. False to mark all as read. (Default: False)
    * @param bool $mark_read Define if the notification as to be set to True or False. (Default: True)
    */
    public function mark_notifications($notification_type_name, $item_id, $user_id, $time = false, $mark_read = true)
    {
        if (is_array($notification_type_name))
        {
            $notification_type_id = $this->get_notification_type_ids($notification_type_name);
        }
        else if ($notification_type_name !== false)
        {
            $notification_type_id = $this->get_notification_type_id($notification_type_name);
        }
        else
        {
            $notification_type_id = false;
        }
        /** @var method\method_interface $method */
        foreach ($this->get_available_subscription_methods() as $method)
        {
            $method->mark_notifications($notification_type_id, $item_id, $user_id, $time, $mark_read);
        }
    }
    /**
     * Mark notifications read or unread from a parent identifier for all available methods
     *
     * @param string|array $notification_type_name Type identifier or array of item types (only acceptable if the $data is identical for the specified types)
     * @param bool|int|array $item_parent_id Item parent id or array of item parent ids. False to mark read for all item parent ids
     * @param bool|int|array $user_id User id or array of user ids. False to mark read for all user ids
     * @param bool|int $time Time at which to mark all notifications prior to as read. False to mark all as read. (Default: False)
     *
     * @deprecated since 3.2
     */
    public function mark_notifications_read_by_parent($notification_type_name, $item_parent_id, $user_id, $time = false)
    {
        $this->mark_notifications_by_parent($notification_type_name, $item_parent_id, $user_id, $time);
    }
    /**
    * Mark notifications read or unread from a parent identifier for all available methods
    *
    * @param string|array $notification_type_name Type identifier or array of item types (only acceptable if the $data is identical for the specified types)
    * @param bool|int|array $item_parent_id Item parent id or array of item parent ids. False to mark read for all item parent ids
    * @param bool|int|array $user_id User id or array of user ids. False to mark read for all user ids
    * @param bool|int $time Time at which to mark all notifications prior to as read. False to mark all as read. (Default: False)
    * @param bool $mark_read Define if the notification as to be set to True or False. (Default: True)
    */
    public function mark_notifications_by_parent($notification_type_name, $item_parent_id, $user_id, $time = false, $mark_read = true)
    {
        if (is_array($notification_type_name))
        {
            $notification_type_id = $this->get_notification_type_ids($notification_type_name);
        }
        else
        {
            $notification_type_id = $this->get_notification_type_id($notification_type_name);
        }
        /** @var method\method_interface $method */
        foreach ($this->get_available_subscription_methods() as $method)
        {
            $method->mark_notifications_by_parent($notification_type_id, $item_parent_id, $user_id, $time, $mark_read);
        }
    }
    /**
    * Mark notifications read or unread for a given method
    *
    * @param string $method_name
    * @param int|array $notification_id Notification id or array of notification ids.
    * @param bool|int $time Time at which to mark all notifications prior to as read. False to mark all as read. (Default: False)
    * @param bool $mark_read Define if the notification as to be set to True or False. (Default: True)
    */
    public function mark_notifications_by_id($method_name, $notification_id, $time = false, $mark_read = true)
    {
        $method = $this->get_method_class($method_name);
        if ($method instanceof \phpbb\notification\method\method_interface && $method->is_available())
        {
            $method->mark_notifications_by_id($notification_id, $time, $mark_read);
        }
    }
    /**
    * Add a notification
    *
    * @param string|array $notification_type_name Type identifier or array of item types (only acceptable if the $data is identical for the specified types)
    *            Note: If you send an array of types, any user who could receive multiple notifications from this single item will only receive
    *             a single notification. If they MUST receive multiple notifications, call this function multiple times instead of sending an array
    * @param array $data Data specific for this type that will be inserted
    * @param array $options Optional options to control what notifications are loaded
    *             ignore_users    array of data to specify which users should not receive certain types of notifications
    * @return array Information about what users were notified and how they were notified
    */
    public function add_notifications($notification_type_name, $data, array $options = array())
    {
        $options = array_merge(array(
            'ignore_users'        => array(),
        ), $options);
        $notified_users = [];
        $add_notifications_override = false;
        /**
        * Get notification data before find_users_for_notification() execute
        *
        * @event core.notification_manager_add_notifications_before
        * @var    bool            add_notifications_override    Flag indicating whether function should return after event
        * @var    array|string    notification_type_name        Type identifier or array of item types
        * @var    string            data                        Data specific for this notification type that will be inserted
        * @var    array             notified_users                Array of notified users
        * @var    string            options                        Optional options to control what notifications are loaded
        * @since 3.3.6-RC1
        */
        $vars = [
            'add_notifications_override',
            'notification_type_name',
            'data',
            'notified_users',
            'options',
        ];
        extract($this->phpbb_dispatcher->trigger_event('core.notification_manager_add_notifications_before', compact($vars)));
        if ($add_notifications_override)
        {
            return $notified_users;
        }
        if (is_array($notification_type_name))
        {
            $temp_options = $options;
            foreach ($notification_type_name as $type)
            {
                $temp_options['ignore_users'] = $options['ignore_users'] + $notified_users;
                $notified_users += $this->add_notifications($type, $data, $temp_options);
            }
            return $notified_users;
        }
        // find out which users want to receive this type of notification
        $notify_users = $this->get_item_type_class($notification_type_name)->find_users_for_notification($data, $options);
        /**
        * Allow filtering the notify_users array for a notification that is about to be sent.
        * Here, $notify_users is already filtered by f_read and the ignored list included in the options variable
        *
        * @event core.notification_manager_add_notifications
        * @var    string    notification_type_name        The notification type identifier
        * @var    array     data                        Data specific for the notification_type_name used will be inserted
        * @var    array     notify_users                The array of userid that are going to be notified for this notification. Set to array() to cancel.
        * @var    array     options                        The options that were used when this method was called (read only)
        *
        * @since 3.1.3-RC1
        */
        $vars = array(
            'notification_type_name',
            'data',
            'notify_users',
            'options',
        );
        extract($this->phpbb_dispatcher->trigger_event('core.notification_manager_add_notifications', compact($vars)));
        $this->add_notifications_for_users($notification_type_name, $data, $notify_users);
        return $notify_users;
    }
    /**
    * Add a notification for specific users
    *
    * @param string|array $notification_type_name Type identifier or array of item types (only acceptable if the $data is identical for the specified types)
    * @param array $data Data specific for this type that will be inserted
    * @param array $notify_users User list to notify
    */
    public function add_notifications_for_users($notification_type_name, $data, $notify_users)
    {
        if (is_array($notification_type_name))
        {
            foreach ($notification_type_name as $type)
            {
                $this->add_notifications_for_users($type, $data, $notify_users);
            }
            return;
        }
        $notification_type_id = $this->get_notification_type_id($notification_type_name);
        $item_id = $this->get_item_type_class($notification_type_name)->get_item_id($data);
        $user_ids = array();
        $notification_methods = array();
        // Never send notifications to the anonymous user!
        unset($notify_users[ANONYMOUS]);
        // Make sure not to send new notifications to users who've already been notified about this item
        // This may happen when an item was added, but now new users are able to see the item
        // We remove each user which was already notified by at least one method.
        /** @var method\method_interface $method */
        foreach ($this->get_subscription_methods_instances() as $method)
        {
            $notified_users = $method->get_notified_users($notification_type_id, array('item_id' => $item_id));
            foreach ($notified_users as $user => $notifications)
            {
                unset($notify_users[$user]);
            }
        }
        /**
        * Allow filtering the $notify_users array by $notification_type_name for a notification that is about to be sent.
        * Here, $notify_users is already filtered from users who've already been notified.
        *
        * @event core.notification_manager_add_notifications_for_users_modify_data
        * @var    string    notification_type_name        The notification type identifier
        * @var    array     data                        Data specific for this type that will be inserted
        * @var    array     notify_users                User list to notify
        *
        * @since 3.2.10-RC1
        * @since 3.3.1-RC1
        */
        $vars = [
            'notification_type_name',
            'data',
            'notify_users',
        ];
        extract($this->phpbb_dispatcher->trigger_event('core.notification_manager_add_notifications_for_users_modify_data', compact($vars)));
        if (!count($notify_users))
        {
            return;
        }
        // Allow notifications to perform actions before creating the insert array (such as run a query to cache some data needed for all notifications)
        $notification = $this->get_item_type_class($notification_type_name);
        $pre_create_data = $notification->pre_create_insert_array($data, $notify_users);
        unset($notification);
        // Go through each user so we can insert a row in the DB and then notify them by their desired means
        foreach ($notify_users as $user => $methods)
        {
            $notification = $this->get_item_type_class($notification_type_name);
            $notification->user_id = (int) $user;
            // Generate the insert_array
            $notification->create_insert_array($data, $pre_create_data);
            // Users are needed to send notifications
            $user_ids = array_merge($user_ids, $notification->users_to_query());
            foreach ($methods as $method)
            {
                // Do not load non-existent notification methods
                if (!isset($this->notification_methods[$method]))
                {
                    continue;
                }
                // Setup the notification methods and add the notification to the queue
                if (!isset($notification_methods[$method]))
                {
                    $notification_methods[$method] = $this->get_method_class($method);
                }
                $notification_methods[$method]->add_to_queue($notification);
            }
        }
        // We need to load all of the users to send notifications
        $this->user_loader->load_users($user_ids);
        // run the queue for each method to send notifications
        foreach ($notification_methods as $method)
        {
            $method->notify();
        }
    }
    /**
    * Update notification
    *
    * @param string|array $notification_type_name Type identifier or array of item types (only acceptable if the $data is identical for the specified types)
    * @param array $data Data specific for this type that will be updated
    * @param array $options
    */
    public function update_notifications($notification_type_name, array $data, array $options = array())
    {
        if (is_array($notification_type_name))
        {
            foreach ($notification_type_name as $type)
            {
                $this->update_notifications($type, $data);
            }
            return;
        }
        $this->update_notification($this->get_item_type_class($notification_type_name), $data, $options);
    }
    /**
    * Update a notification
    *
    * @param \phpbb\notification\type\type_interface $notification The notification
    * @param array $data Data specific for this type that will be updated
    * @param array $options
    */
    public function update_notification(\phpbb\notification\type\type_interface $notification, array $data, array $options = array())
    {
        if (empty($options))
        {
            $options['item_id'] = $notification->get_item_id($data);
        }
        /** @var method\method_interface $method */
        foreach ($this->get_available_subscription_methods() as $method)
        {
            $method->update_notification($notification, $data, $options);
        }
    }
    /**
    * Delete a notification
    *
    * @param string|array $notification_type_name Type identifier or array of item types (only acceptable if the $item_id is identical for the specified types)
    * @param int|array $item_id Identifier within the type (or array of ids)
    * @param mixed $parent_id Parent identifier within the type (or array of ids), used in combination with item_id if specified (Default: false; not checked)
    * @param mixed $user_id User id (Default: false; not checked)
    */
    public function delete_notifications($notification_type_name, $item_id, $parent_id = false, $user_id = false)
    {
        if (is_array($notification_type_name))
        {
            foreach ($notification_type_name as $type)
            {
                $this->delete_notifications($type, $item_id, $parent_id, $user_id);
            }
            return;
        }
        $notification_type_id = $this->get_notification_type_id($notification_type_name);
        /** @var method\method_interface $method */
        foreach ($this->get_available_subscription_methods() as $method)
        {
            $method->delete_notifications($notification_type_id, $item_id, $parent_id, $user_id);
        }
    }
    /**
    * Get all of the subscription types
    *
    * @return array Array of item types
    */
    public function get_subscription_types()
    {
        if ($this->subscription_types === null)
        {
            $this->subscription_types = array();
            foreach ($this->notification_types as $type_name => $data)
            {
                /** @var type\base $type */
                $type = $this->get_item_type_class($type_name);
                if ($type instanceof \phpbb\notification\type\type_interface && $type->is_available())
                {
                    $options = array_merge(array(
                        'type'    => $type,
                        'id'    => $type->get_type(),
                        'lang'    => 'NOTIFICATION_TYPE_' . strtoupper($type->get_type()),
                        'group'    => 'NOTIFICATION_GROUP_MISCELLANEOUS',
                    ), (($type::$notification_option !== false) ? $type::$notification_option : array()));
                    $this->subscription_types[$options['group']][$options['id']] = $options;
                }
            }
            // Move Miscellaneous to the very last section
            if (isset($this->subscription_types['NOTIFICATION_GROUP_MISCELLANEOUS']))
            {
                $miscellaneous = $this->subscription_types['NOTIFICATION_GROUP_MISCELLANEOUS'];
                unset($this->subscription_types['NOTIFICATION_GROUP_MISCELLANEOUS']);
                $this->subscription_types['NOTIFICATION_GROUP_MISCELLANEOUS'] = $miscellaneous;
            }
        }
        return $this->subscription_types;
    }
    /**
    * Get all of the subscription methods
    *
    * @return array Array of methods
    */
    public function get_subscription_methods()
    {
        $subscription_methods = array();
        /** @var method\method_interface $method */
        foreach ($this->get_available_subscription_methods() as $method_name => $method)
        {
            $subscription_methods[$method_name] = array(
                'method'    => $method,
                'id'        => $method->get_type(),
                'lang'        => str_replace('.', '_', strtoupper($method->get_type())),
            );
        }
        return $subscription_methods;
    }
    /**
    * Get all of the subscription methods
    *
    * @return array Array of method's instances
    */
    private function get_subscription_methods_instances()
    {
        $subscription_methods = array();
        foreach ($this->notification_methods as $method_name => $data)
        {
            $method = $this->get_method_class($method_name);
            if ($method instanceof \phpbb\notification\method\method_interface)
            {
                $subscription_methods[$method_name] = $method;
            }
        }
        return $subscription_methods;
    }
    /**
    * Get all of the available subscription methods
    *
    * @return array Array of method's instances
    */
    private function get_available_subscription_methods()
    {
        $subscription_methods = array();
        /** @var method\method_interface $method */
        foreach ($this->get_subscription_methods_instances() as $method_name => $method)
        {
            if ($method->is_available())
            {
                $subscription_methods[$method_name] = $method;
            }
        }
        return $subscription_methods;
    }
    /**
    * Get user's notification data
    *
    * @param int $user_id The user_id of the user to get the notifications for
    *
    * @return array User's notification
    */
    protected function get_user_notifications($user_id)
    {
        $sql = 'SELECT method, notify, item_type
                FROM ' . $this->user_notifications_table . '
                WHERE user_id = ' . (int) $user_id . '
                    AND item_id = 0';
        $result = $this->db->sql_query($sql);
        $user_notifications = array();
        while ($row = $this->db->sql_fetchrow($result))
        {
            $user_notifications[$row['item_type']][] = $row;
        }
        $this->db->sql_freeresult($result);
        return $user_notifications;
    }
    /**
    * Get global subscriptions (item_id = 0)
    *
    * @param bool|int $user_id The user_id to add the subscription for (bool false for current user)
    *
    * @return array Subscriptions
    */
    public function get_global_subscriptions($user_id = false)
    {
        $user_id = $user_id ?: $this->user->data['user_id'];
        $subscriptions = array();
        $default_methods = $this->get_default_methods();
        $user_notifications = $this->get_user_notifications($user_id);
        foreach ($this->get_subscription_types() as $types)
        {
            foreach ($types as $id => $type)
            {
                $type_subscriptions = $default_methods;
                if (!empty($user_notifications[$id]))
                {
                    foreach ($user_notifications[$id] as $user_notification)
                    {
                        $key = array_search($user_notification['method'], $type_subscriptions, true);
                        if (!$user_notification['notify'])
                        {
                            if ($key !== false)
                            {
                                unset($type_subscriptions[$key]);
                            }
                            continue;
                        }
                        else if ($key === false)
                        {
                            $type_subscriptions[] = $user_notification['method'];
                        }
                    }
                }
                if (!empty($type_subscriptions))
                {
                    $subscriptions[$id] = $type_subscriptions;
                }
            }
        }
        return $subscriptions;
    }
    /**
    * Add a subscription
    *
    * @param string $item_type Type identifier of the subscription
    * @param int $item_id The id of the item
    * @param string $method The method of the notification e.g. 'board', 'email', or 'jabber'
    *                       (if null a subscription will be added for all the defaults methods)
    * @param bool|int $user_id The user_id to add the subscription for (bool false for current user)
    */
    public function add_subscription($item_type, $item_id = 0, $method = null, $user_id = false)
    {
        if ($method === null)
        {
            foreach ($this->get_default_methods() as $method_name)
            {
                $this->add_subscription($item_type, $item_id, $method_name, $user_id);
            }
            return;
        }
        $user_id = ($user_id === false) ? $this->user->data['user_id'] : $user_id;
        $sql = 'SELECT notify
            FROM ' . $this->user_notifications_table . "
            WHERE item_type = '" . $this->db->sql_escape($item_type) . "'
                AND item_id = " . (int) $item_id . '
                AND user_id = ' .(int) $user_id . "
                AND method = '" . $this->db->sql_escape($method) . "'";
        $this->db->sql_query($sql);
        $current = $this->db->sql_fetchfield('notify');
        $this->db->sql_freeresult();
        if ($current === false)
        {
            $sql = 'INSERT INTO ' . $this->user_notifications_table . ' ' .
                $this->db->sql_build_array('INSERT', array(
                    'item_type'        => $item_type,
                    'item_id'        => (int) $item_id,
                    'user_id'        => (int) $user_id,
                    'method'        => $method,
                    'notify'        => 1,
                ));
            $this->db->sql_query($sql);
        }
        else if (!$current)
        {
            $sql = 'UPDATE ' . $this->user_notifications_table . "
                SET notify = 1
                WHERE item_type = '" . $this->db->sql_escape($item_type) . "'
                    AND item_id = " . (int) $item_id . '
                    AND user_id = ' .(int) $user_id . "
                    AND method = '" . $this->db->sql_escape($method) . "'";
            $this->db->sql_query($sql);
        }
    }
    /**
    * Delete a subscription
    *
    * @param string $item_type Type identifier of the subscription
    * @param int $item_id The id of the item
    * @param string $method The method of the notification e.g. 'board', 'email', or 'jabber'
    * @param bool|int $user_id The user_id to add the subscription for (bool false for current user)
    */
    public function delete_subscription($item_type, $item_id = 0, $method = null, $user_id = false)
    {
        if ($method === null)
        {
            foreach ($this->get_default_methods() as $method_name)
            {
                $this->delete_subscription($item_type, $item_id, $method_name, $user_id);
            }
            return;
        }
        $user_id = $user_id ?: $this->user->data['user_id'];
        $sql = 'UPDATE ' . $this->user_notifications_table . "
            SET notify = 0
            WHERE item_type = '" . $this->db->sql_escape($item_type) . "'
                AND item_id = " . (int) $item_id . '
                AND user_id = ' .(int) $user_id . "
                AND method = '" . $this->db->sql_escape($method) . "'";
        $this->db->sql_query($sql);
        if (!$this->db->sql_affectedrows())
        {
            $sql = 'INSERT INTO ' . $this->user_notifications_table . ' ' .
                $this->db->sql_build_array('INSERT', array(
                    'item_type'        => $item_type,
                    'item_id'        => (int) $item_id,
                    'user_id'        => (int) $user_id,
                    'method'        => $method,
                    'notify'        => 0,
                ));
            $this->db->sql_query($sql);
        }
    }
    /**
    * Disable all notifications of a certain type
    *
    * This should be called when an extension which has notification types
    * is disabled so that all those notifications are hidden and do not
    * cause errors
    *
    * @param string $notification_type_name Type identifier of the subscription
    */
    public function disable_notifications($notification_type_name)
    {
        $sql = 'UPDATE ' . $this->notification_types_table . "
            SET notification_type_enabled = 0
            WHERE notification_type_name = '" . $this->db->sql_escape($notification_type_name) . "'";
        $this->db->sql_query($sql);
    }
    /**
    * Purge all notifications of a certain type
    *
    * This should be called when an extension which has notification types
    * is purged so that all those notifications are removed
    *
    * @param string $notification_type_name Type identifier of the subscription
    */
    public function purge_notifications($notification_type_name)
    {
        // If a notification is never used, its type will not be added to the database
        // nor its id cached. If this method is called by an extension during the
        // purge step, and that extension never used its notifications,
        // get_notification_type_id() will throw an exception. However,
        // because no notification type was added to the database,
        // there is nothing to delete, so we can silently drop the exception.
        try
        {
            $notification_type_id = $this->get_notification_type_id($notification_type_name);
            /** @var method\method_interface $method */
            foreach ($this->get_available_subscription_methods() as $method)
            {
                $method->purge_notifications($notification_type_id);
            }
        }
        catch (\phpbb\notification\exception $e)
        {
            // Continue
        }
    }
    /**
    * Enable all notifications of a certain type
    *
    * This should be called when an extension which has notification types
    * that was disabled is re-enabled so that all those notifications that
    * were hidden are shown again
    *
    * @param string $notification_type_name Type identifier of the subscription
    */
    public function enable_notifications($notification_type_name)
    {
        $sql = 'UPDATE ' . $this->notification_types_table . "
            SET notification_type_enabled = 1
            WHERE notification_type_name = '" . $this->db->sql_escape($notification_type_name) . "'";
        $this->db->sql_query($sql);
    }
    /**
    * Delete all notifications older than a certain time
    *
    * @param int $timestamp Unix timestamp to delete all notifications that were created before
    * @param bool $only_read True (default) to only prune read notifications
    */
    public function prune_notifications($timestamp, $only_read = true)
    {
        /** @var method\method_interface $method */
        foreach ($this->get_available_subscription_methods() as $method)
        {
            $method->prune_notifications($timestamp, $only_read);
        }
    }
    /**
     * Helper to get the list of methods enabled by default
     *
     * @return method\method_interface[]
     */
    public function get_default_methods()
    {
        $default_methods = array();
        foreach ($this->notification_methods as $method)
        {
            if ($method->is_enabled_by_default() && $method->is_available())
            {
                $default_methods[] = $method->get_type();
            }
        }
        return $default_methods;
    }
    /**
     * Helper to get the notifications item type class and set it up
     *
     * @param string $notification_type_name
     * @param array  $data
     * @return type\type_interface
     */
    public function get_item_type_class($notification_type_name, $data = array())
    {
        $item = $this->load_object($notification_type_name);
        $item->set_initial_data($data);
        return $item;
    }
    /**
     * Helper to get the notifications method class and set it up
     *
     * @param string $method_name
     * @return method\method_interface
     */
    public function get_method_class($method_name)
    {
        return $this->load_object($method_name);
    }
    /**
     * Helper to load objects (notification types/methods)
     *
     * @param string $object_name
     * @return method\method_interface|type\type_interface
     */
    protected function load_object($object_name)
    {
        $object = $this->phpbb_container->get($object_name);
        if (method_exists($object, 'set_notification_manager'))
        {
            $object->set_notification_manager($this);
        }
        return $object;
    }
    /**
    * Get the notification type id from the name
    *
    * @param string $notification_type_name The name
    * @return int the notification_type_id
    * @throws \phpbb\notification\exception
    */
    public function get_notification_type_id($notification_type_name)
    {
        $sql = 'SELECT notification_type_id, notification_type_name
            FROM ' . $this->notification_types_table;
        $result = $this->db->sql_query($sql, 604800); // cache for one week
        while ($row = $this->db->sql_fetchrow($result))
        {
            $notification_type_ids[$row['notification_type_name']] = (int) $row['notification_type_id'];
        }
        $this->db->sql_freeresult($result);
        if (!isset($notification_type_ids[$notification_type_name]))
        {
            if (!isset($this->notification_types[$notification_type_name]) && !isset($this->notification_types['notification.type.' . $notification_type_name]))
            {
                throw new \phpbb\notification\exception('NOTIFICATION_TYPE_NOT_EXIST', array($notification_type_name));
            }
            $sql = 'INSERT INTO ' . $this->notification_types_table . ' ' . $this->db->sql_build_array('INSERT', array(
                'notification_type_name'        => $notification_type_name,
                'notification_type_enabled'        => 1,
            ));
            $this->db->sql_query($sql);
            // expose new notification type ID for this request
            $notification_type_ids[$notification_type_name] = (int) $this->db->sql_nextid();
            // destroy cache, we have a new addition which we have to to load next time
            $this->cache->destroy('sql', $this->notification_types_table);
        }
        return $notification_type_ids[$notification_type_name];
    }
    /**
    * Get notification type ids (as an array)
    *
    * @param string|array $notification_type_names Notification type names
    * @return array Array of integers
    */
    public function get_notification_type_ids($notification_type_names)
    {
        if (!is_array($notification_type_names))
        {
            $notification_type_names = array($notification_type_names);
        }
        $notification_type_ids = array();
        foreach ($notification_type_names as $name)
        {
            $notification_type_ids[$name] = $this->get_notification_type_id($name);
        }
        return $notification_type_ids;
    }
    /**
    * Find the users which are already notified
    *
    * @param bool|string|array $notification_type_name Type identifier or array of item types (only acceptable if the $data is identical for the specified types). False to retrieve all item types
    * @param array $options
    * @return array The list of the notified users
    */
    public function get_notified_users($notification_type_name, array $options)
    {
        $notification_type_id = $this->get_notification_type_id($notification_type_name);
        $notified_users = array();
        /** @var method\method_interface $method */
        foreach ($this->get_available_subscription_methods() as $method)
        {
            $notified_users = $notified_users + $method->get_notified_users($notification_type_id, $options);
        }
        return $notified_users;
    }
}