Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * Forum subscription manager.

 *

 * @package    mod_forum

 * @copyright  2014 Andrew Nicols <andrew@nicols.co.uk>

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

namespace mod_forum;

defined('MOODLE_INTERNAL') || die();

/**

 * Forum subscription manager.

 *

 * @copyright  2014 Andrew Nicols <andrew@nicols.co.uk>

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class subscriptions {

    /**

     * The status value for an unsubscribed discussion.

     *

     * @var int

     */

    const FORUM_DISCUSSION_UNSUBSCRIBED = -1;

    /**

     * The subscription cache for forums.

     *

     * The first level key is the user ID

     * The second level is the forum ID

     * The Value then is bool for subscribed of not.

     *

     * @var array[] An array of arrays.

     */

    protected static $forumcache = array();

    /**

     * The list of forums which have been wholly retrieved for the forum subscription cache.

     *

     * This allows for prior caching of an entire forum to reduce the

     * number of DB queries in a subscription check loop.

     *

     * @var bool[]

     */

    protected static $fetchedforums = array();

    /**

     * The subscription cache for forum discussions.

     *

     * The first level key is the user ID

     * The second level is the forum ID

     * The third level key is the discussion ID

     * The value is then the users preference (int)

     *

     * @var array[]

     */

    protected static $forumdiscussioncache = array();

    /**

     * The list of forums which have been wholly retrieved for the forum discussion subscription cache.

     *

     * This allows for prior caching of an entire forum to reduce the

     * number of DB queries in a subscription check loop.

     *

     * @var bool[]

     */

    protected static $discussionfetchedforums = array();

    /**

     * Whether a user is subscribed to this forum, or a discussion within

     * the forum.

     *

     * If a discussion is specified, then report whether the user is

     * subscribed to posts to this particular discussion, taking into

     * account the forum preference.

     *

     * If it is not specified then only the forum preference is considered.

     *

     * @param int $userid The user ID

     * @param \stdClass $forum The record of the forum to test

     * @param int $discussionid The ID of the discussion to check

     * @param $cm The coursemodule record. If not supplied, this will be calculated using get_fast_modinfo instead.

     * @return boolean

     */

    public static function is_subscribed($userid, $forum, $discussionid = null, $cm = null) {

        // If forum is force subscribed and has allowforcesubscribe, then user is subscribed.

        if (self::is_forcesubscribed($forum)) {

            if (!$cm) {

                $cm = get_fast_modinfo($forum->course)->instances['forum'][$forum->id];

            }

            if (has_capability('mod/forum:allowforcesubscribe', \context_module::instance($cm->id), $userid)) {

                return true;

            }

        }

        if ($discussionid === null) {

            return self::is_subscribed_to_forum($userid, $forum);

        }

        $subscriptions = self::fetch_discussion_subscription($forum->id, $userid);

        // Check whether there is a record for this discussion subscription.

        if (isset($subscriptions[$discussionid])) {

            return ($subscriptions[$discussionid] != self::FORUM_DISCUSSION_UNSUBSCRIBED);

        }

        return self::is_subscribed_to_forum($userid, $forum);

    }

    /**

     * Whether a user is subscribed to this forum.

     *

     * @param int $userid The user ID

     * @param \stdClass $forum The record of the forum to test

     * @return boolean

     */

    protected static function is_subscribed_to_forum($userid, $forum) {

        return self::fetch_subscription_cache($forum->id, $userid);

    }

    /**

     * Helper to determine whether a forum has it's subscription mode set

     * to forced subscription.

     *

     * @param \stdClass $forum The record of the forum to test

     * @return bool

     */

    public static function is_forcesubscribed($forum) {

        return ($forum->forcesubscribe == FORUM_FORCESUBSCRIBE);

    }

    /**

     * Helper to determine whether a forum has it's subscription mode set to disabled.

     *

     * @param \stdClass $forum The record of the forum to test

     * @return bool

     */

    public static function subscription_disabled($forum) {

        return ($forum->forcesubscribe == FORUM_DISALLOWSUBSCRIBE);

    }

    /**

     * Helper to determine whether the specified forum can be subscribed to.

     *

     * @param \stdClass $forum The record of the forum to test

     * @return bool

     */

    public static function is_subscribable($forum) {

        return (isloggedin() && !isguestuser() &&

                !\mod_forum\subscriptions::is_forcesubscribed($forum) &&

                !\mod_forum\subscriptions::subscription_disabled($forum));

    }

    /**

     * Set the forum subscription mode.

     *

     * By default when called without options, this is set to FORUM_FORCESUBSCRIBE.

     *

     * @param \stdClass $forum The record of the forum to set

     * @param int $status The new subscription state

     * @return bool true

     * @throws dml_exception A DML specific exception is thrown for any errors.

     */

    public static function set_subscription_mode($forum, $status = FORUM_FORCESUBSCRIBE): bool {

        global $DB;

        if (is_numeric($forum)) {

            debugging(__METHOD__.': Argument #1 ($forum) must be a stdClass record of a forum', DEBUG_DEVELOPER);

            $forum = $DB->get_record("forum", ["id" => $forum], '*', MUST_EXIST);

        }

        $DB->set_field("forum", "forcesubscribe", $status, ["id" => $forum->id]);

        if ($forum->forcesubscribe != $status) {

            // Trigger event if subscription mode has been changed.

            $event = \mod_forum\event\subscription_mode_updated::create([

                "context" => forum_get_context($forum->id),

                "objectid" => $forum->id,

                "other" => ["oldvalue" => $forum->forcesubscribe, "newvalue" => $status],

            ]);

            $event->add_record_snapshot("forum", $forum);

            $event->trigger();

        }

        return true;

    }

    /**

     * Returns the current subscription mode for the forum.

     *

     * @param \stdClass $forum The record of the forum to set

     * @return int The forum subscription mode

     */

    public static function get_subscription_mode($forum) {

        return $forum->forcesubscribe;

    }

    /**

     * Returns an array of forums that the current user is subscribed to and is allowed to unsubscribe from

     *

     * @return array An array of unsubscribable forums

     */

    public static function get_unsubscribable_forums() {

        global $USER, $DB;

        // Get courses that $USER is enrolled in and can see.

        $courses = enrol_get_my_courses();

        if (empty($courses)) {

            return array();

        }

        $courseids = array();

        foreach($courses as $course) {

            $courseids[] = $course->id;

        }

        list($coursesql, $courseparams) = $DB->get_in_or_equal($courseids, SQL_PARAMS_NAMED, 'c');

        // Get all forums from the user's courses that they are subscribed to and which are not set to forced.

        // It is possible for users to be subscribed to a forum in subscription disallowed mode so they must be listed

        // here so that that can be unsubscribed from.

        $sql = "SELECT f.id, cm.id as cm, cm.visible, f.course

                FROM {forum} f

                JOIN {course_modules} cm ON cm.instance = f.id

                JOIN {modules} m ON m.name = :modulename AND m.id = cm.module

                LEFT JOIN {forum_subscriptions} fs ON (fs.forum = f.id AND fs.userid = :userid)

                WHERE f.forcesubscribe <> :forcesubscribe

                AND fs.id IS NOT NULL

                AND cm.course

                $coursesql";

        $params = array_merge($courseparams, array(

            'modulename'=>'forum',

            'userid' => $USER->id,

            'forcesubscribe' => FORUM_FORCESUBSCRIBE,

        ));

        $forums = $DB->get_recordset_sql($sql, $params);

        $unsubscribableforums = array();

        foreach($forums as $forum) {

            if (empty($forum->visible)) {

                // The forum is hidden - check if the user can view the forum.

                $context = \context_module::instance($forum->cm);

                if (!has_capability('moodle/course:viewhiddenactivities', $context)) {

                    // The user can't see the hidden forum to cannot unsubscribe.

                    continue;

                }

            }

            $unsubscribableforums[] = $forum;

        }

        $forums->close();

        return $unsubscribableforums;

    }

    /**

     * Get the list of potential subscribers to a forum.

     *

     * @param context_module $context the forum context.

     * @param integer $groupid the id of a group, or 0 for all groups.

     * @param string $fields the list of fields to return for each user. As for get_users_by_capability.

     * @param string $sort sort order. As for get_users_by_capability.

     * @return array list of users.

     */

    public static function get_potential_subscribers($context, $groupid, $fields, $sort = '') {

        global $DB;

        // Only active enrolled users or everybody on the frontpage.

        list($esql, $params) = get_enrolled_sql($context, 'mod/forum:allowforcesubscribe', $groupid, true);

        if (!$sort) {

            list($sort, $sortparams) = users_order_by_sql('u');

            $params = array_merge($params, $sortparams);

        }

        $sql = "SELECT $fields

                FROM {user} u

                JOIN ($esql) je ON je.id = u.id

               WHERE u.auth <> 'nologin' AND u.suspended = 0 AND u.confirmed = 1

            ORDER BY $sort";

        return $DB->get_records_sql($sql, $params);

    }

    /**

     * Fetch the forum subscription data for the specified userid and forum.

     *

     * @param int $forumid The forum to retrieve a cache for

     * @param int $userid The user ID

     * @return boolean

     */

    public static function fetch_subscription_cache($forumid, $userid) {

        if (isset(self::$forumcache[$userid]) && isset(self::$forumcache[$userid][$forumid])) {

            return self::$forumcache[$userid][$forumid];

        }

        self::fill_subscription_cache($forumid, $userid);

        if (!isset(self::$forumcache[$userid]) || !isset(self::$forumcache[$userid][$forumid])) {

            return false;

        }

        return self::$forumcache[$userid][$forumid];

    }

    /**

     * Fill the forum subscription data for the specified userid and forum.

     *

     * If the userid is not specified, then all subscription data for that forum is fetched in a single query and used

     * for subsequent lookups without requiring further database queries.

     *

     * @param int $forumid The forum to retrieve a cache for

     * @param int $userid The user ID

     * @return void

     */

    public static function fill_subscription_cache($forumid, $userid = null) {

        global $DB;

        if (!isset(self::$fetchedforums[$forumid])) {

            // This forum has not been fetched as a whole.

            if (isset($userid)) {

                if (!isset(self::$forumcache[$userid])) {

                    self::$forumcache[$userid] = array();

                }

                if (!isset(self::$forumcache[$userid][$forumid])) {

                    if ($DB->record_exists('forum_subscriptions', array(

                        'userid' => $userid,

                        'forum' => $forumid,

                    ))) {

                        self::$forumcache[$userid][$forumid] = true;

                    } else {

                        self::$forumcache[$userid][$forumid] = false;

                    }

                }

            } else {

                $subscriptions = $DB->get_recordset('forum_subscriptions', array(

                    'forum' => $forumid,

                ), '', 'id, userid');

                foreach ($subscriptions as $id => $data) {

                    if (!isset(self::$forumcache[$data->userid])) {

                        self::$forumcache[$data->userid] = array();

                    }

                    self::$forumcache[$data->userid][$forumid] = true;

                }

                self::$fetchedforums[$forumid] = true;

                $subscriptions->close();

            }

        }

    }

    /**

     * Fill the forum subscription data for all forums that the specified userid can subscribe to in the specified course.

     *

     * @param int $courseid The course to retrieve a cache for

     * @param int $userid The user ID

     * @return void

     */

    public static function fill_subscription_cache_for_course($courseid, $userid) {

        global $DB;

        if (!isset(self::$forumcache[$userid])) {

            self::$forumcache[$userid] = array();

        }

        $sql = "SELECT

                    f.id AS forumid,

                    s.id AS subscriptionid

                FROM {forum} f

                LEFT JOIN {forum_subscriptions} s ON (s.forum = f.id AND s.userid = :userid)

                WHERE f.course = :course

                AND f.forcesubscribe <> :subscriptionforced";

        $subscriptions = $DB->get_recordset_sql($sql, array(

            'course' => $courseid,

            'userid' => $userid,

            'subscriptionforced' => FORUM_FORCESUBSCRIBE,

        ));

        foreach ($subscriptions as $id => $data) {

            self::$forumcache[$userid][$id] = !empty($data->subscriptionid);

        }

        $subscriptions->close();

    }

    /**

     * Returns a list of user objects who are subscribed to this forum.

     *

     * @param stdClass $forum The forum record.

     * @param int $groupid The group id if restricting subscriptions to a group of users, or 0 for all.

     * @param context_module $context the forum context, to save re-fetching it where possible.

     * @param string $fields requested user fields (with "u." table prefix).

     * @param boolean $includediscussionsubscriptions Whether to take discussion subscriptions and unsubscriptions into consideration.

     * @return array list of users.

     */

    public static function fetch_subscribed_users($forum, $groupid = 0, $context = null, $fields = null,

            $includediscussionsubscriptions = false) {

        global $CFG, $DB;

        if (empty($fields)) {

            $userfieldsapi = \core_user\fields::for_name();

            $allnames = $userfieldsapi->get_sql('u', false, '', '', false)->selects;

            $fields ="u.id,

                      u.username,

                      $allnames,

                      u.maildisplay,

                      u.mailformat,

                      u.maildigest,

                      u.imagealt,

                      u.email,

                      u.emailstop,

                      u.city,

                      u.country,

                      u.lastaccess,

                      u.lastlogin,

                      u.picture,

                      u.timezone,

                      u.theme,

                      u.lang,

                      u.trackforums,

                      u.mnethostid";

        }

        // Retrieve the forum context if it wasn't specified.

        $context = forum_get_context($forum->id, $context);

        if (self::is_forcesubscribed($forum)) {

            $results = self::get_potential_subscribers($context, $groupid, $fields);

        } else {

            // Only active enrolled users or everybody on the frontpage.

            list($esql, $params) = get_enrolled_sql($context, '', $groupid, true);

            $params['forumid'] = $forum->id;

            list($sort, $sortparams) = users_order_by_sql('u');

            $params = array_merge($params, $sortparams);

            if ($includediscussionsubscriptions) {

                $params['sforumid'] = $forum->id;

                $params['dsforumid'] = $forum->id;

                $params['unsubscribed'] = self::FORUM_DISCUSSION_UNSUBSCRIBED;

                $sql = "SELECT $fields

                        FROM (

                            SELECT userid FROM {forum_subscriptions} s

                            WHERE

                                s.forum = :sforumid

                                UNION

                            SELECT userid FROM {forum_discussion_subs} ds

                            WHERE

                                ds.forum = :dsforumid AND ds.preference <> :unsubscribed

                        ) subscriptions

                        JOIN {user} u ON u.id = subscriptions.userid

                        JOIN ($esql) je ON je.id = u.id

                        WHERE u.auth <> 'nologin' AND u.suspended = 0 AND u.confirmed = 1

                        ORDER BY $sort";

            } else {

                $sql = "SELECT $fields

                        FROM {user} u

                        JOIN ($esql) je ON je.id = u.id

                        JOIN {forum_subscriptions} s ON s.userid = u.id

                        WHERE

                          s.forum = :forumid AND u.auth <> 'nologin' AND u.suspended = 0 AND u.confirmed = 1

                        ORDER BY $sort";

            }

            $results = $DB->get_records_sql($sql, $params);

        }

        // Guest user should never be subscribed to a forum.

        unset($results[$CFG->siteguest]);

        // Apply the activity module availability resetrictions.

        $cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course);

        $modinfo = get_fast_modinfo($forum->course);

        $info = new \core_availability\info_module($modinfo->get_cm($cm->id));

        $results = $info->filter_user_list($results);

        return $results;

    }

    /**

     * Retrieve the discussion subscription data for the specified userid and forum.

     *

     * This is returned as an array of discussions for that forum which contain the preference in a stdClass.

     *

     * @param int $forumid The forum to retrieve a cache for

     * @param int $userid The user ID

     * @return array of stdClass objects with one per discussion in the forum.

     */

    public static function fetch_discussion_subscription($forumid, $userid = null) {

        self::fill_discussion_subscription_cache($forumid, $userid);

        if (!isset(self::$forumdiscussioncache[$userid]) || !isset(self::$forumdiscussioncache[$userid][$forumid])) {

            return array();

        }

        return self::$forumdiscussioncache[$userid][$forumid];

    }

    /**

     * Fill the discussion subscription data for the specified userid and forum.

     *

     * If the userid is not specified, then all discussion subscription data for that forum is fetched in a single query

     * and used for subsequent lookups without requiring further database queries.

     *

     * @param int $forumid The forum to retrieve a cache for

     * @param int $userid The user ID

     * @return void

     */

    public static function fill_discussion_subscription_cache($forumid, $userid = null) {

        global $DB;

        if (!isset(self::$discussionfetchedforums[$forumid])) {

            // This forum hasn't been fetched as a whole yet.

            if (isset($userid)) {

                if (!isset(self::$forumdiscussioncache[$userid])) {

                    self::$forumdiscussioncache[$userid] = array();

                }

                if (!isset(self::$forumdiscussioncache[$userid][$forumid])) {

                    $subscriptions = $DB->get_recordset('forum_discussion_subs', array(

                        'userid' => $userid,

                        'forum' => $forumid,

                    ), null, 'id, discussion, preference');

                    self::$forumdiscussioncache[$userid][$forumid] = array();

                    foreach ($subscriptions as $id => $data) {

                        self::add_to_discussion_cache($forumid, $userid, $data->discussion, $data->preference);

                    }

                    $subscriptions->close();

                }

            } else {

                $subscriptions = $DB->get_recordset('forum_discussion_subs', array(

                    'forum' => $forumid,

                ), null, 'id, userid, discussion, preference');

                foreach ($subscriptions as $id => $data) {

                    self::add_to_discussion_cache($forumid, $data->userid, $data->discussion, $data->preference);

                }

                self::$discussionfetchedforums[$forumid] = true;

                $subscriptions->close();

            }

        }

    }

    /**

     * Add the specified discussion and user preference to the discussion

     * subscription cache.

     *

     * @param int $forumid The ID of the forum that this preference belongs to

     * @param int $userid The ID of the user that this preference belongs to

     * @param int $discussion The ID of the discussion that this preference relates to

     * @param int $preference The preference to store

     */

    protected static function add_to_discussion_cache($forumid, $userid, $discussion, $preference) {

        if (!isset(self::$forumdiscussioncache[$userid])) {

            self::$forumdiscussioncache[$userid] = array();

        }

        if (!isset(self::$forumdiscussioncache[$userid][$forumid])) {

            self::$forumdiscussioncache[$userid][$forumid] = array();

        }

        self::$forumdiscussioncache[$userid][$forumid][$discussion] = $preference;

    }

    /**

     * Reset the discussion cache.

     *

     * This cache is used to reduce the number of database queries when

     * checking forum discussion subscription states.

     */

    public static function reset_discussion_cache() {

        self::$forumdiscussioncache = array();

        self::$discussionfetchedforums = array();

    }

    /**

     * Reset the forum cache.

     *

     * This cache is used to reduce the number of database queries when

     * checking forum subscription states.

     */

    public static function reset_forum_cache() {

        self::$forumcache = array();

        self::$fetchedforums = array();

    }

    /**

     * Adds user to the subscriber list.

     *

     * @param int $userid The ID of the user to subscribe

     * @param \stdClass $forum The forum record for this forum.

     * @param \context_module|null $context Module context, may be omitted if not known or if called for the current

     *      module set in page.

     * @param boolean $userrequest Whether the user requested this change themselves. This has an effect on whether

     *     discussion subscriptions are removed too.

     * @return bool|int Returns true if the user is already subscribed, or the forum_subscriptions ID if the user was

     *     successfully subscribed.

     */

    public static function subscribe_user($userid, $forum, $context = null, $userrequest = false) {

        global $DB;

        if (self::is_subscribed($userid, $forum)) {

            return true;

        }

        $sub = new \stdClass();

        $sub->userid  = $userid;

        $sub->forum = $forum->id;

        $result = $DB->insert_record("forum_subscriptions", $sub);

        if ($userrequest) {

            $discussionsubscriptions = $DB->get_recordset('forum_discussion_subs', array('userid' => $userid, 'forum' => $forum->id));

            $DB->delete_records_select('forum_discussion_subs',

                    'userid = :userid AND forum = :forumid AND preference <> :preference', array(

                        'userid' => $userid,

                        'forumid' => $forum->id,

                        'preference' => self::FORUM_DISCUSSION_UNSUBSCRIBED,

                    ));

            // Reset the subscription caches for this forum.

            // We know that the there were previously entries and there aren't any more.

            if (isset(self::$forumdiscussioncache[$userid]) && isset(self::$forumdiscussioncache[$userid][$forum->id])) {

                foreach (self::$forumdiscussioncache[$userid][$forum->id] as $discussionid => $preference) {

                    if ($preference != self::FORUM_DISCUSSION_UNSUBSCRIBED) {

                        unset(self::$forumdiscussioncache[$userid][$forum->id][$discussionid]);

                    }

                }

            }

        }

        // Reset the cache for this forum.

        self::$forumcache[$userid][$forum->id] = true;

        $context = forum_get_context($forum->id, $context);

        $params = array(

            'context' => $context,

            'objectid' => $result,

            'relateduserid' => $userid,

            'other' => array('forumid' => $forum->id),

        );

        $event  = event\subscription_created::create($params);

        if ($userrequest && $discussionsubscriptions) {

            foreach ($discussionsubscriptions as $subscription) {

                $event->add_record_snapshot('forum_discussion_subs', $subscription);

            }

            $discussionsubscriptions->close();

        }

        $event->trigger();

        return $result;

    }

    /**

     * Removes user from the subscriber list

     *

     * @param int $userid The ID of the user to unsubscribe

     * @param \stdClass $forum The forum record for this forum.

     * @param \context_module|null $context Module context, may be omitted if not known or if called for the current

     *     module set in page.

     * @param boolean $userrequest Whether the user requested this change themselves. This has an effect on whether

     *     discussion subscriptions are removed too.

     * @return boolean Always returns true.

     */

    public static function unsubscribe_user($userid, $forum, $context = null, $userrequest = false) {

        global $DB;

        $sqlparams = array(

            'userid' => $userid,

            'forum' => $forum->id,

        );

        $DB->delete_records('forum_digests', $sqlparams);

        if ($forumsubscription = $DB->get_record('forum_subscriptions', $sqlparams)) {

            $DB->delete_records('forum_subscriptions', array('id' => $forumsubscription->id));

            if ($userrequest) {

                $discussionsubscriptions = $DB->get_recordset('forum_discussion_subs', $sqlparams);

                $DB->delete_records('forum_discussion_subs',

                        array('userid' => $userid, 'forum' => $forum->id, 'preference' => self::FORUM_DISCUSSION_UNSUBSCRIBED));

                // We know that the there were previously entries and there aren't any more.

                if (isset(self::$forumdiscussioncache[$userid]) && isset(self::$forumdiscussioncache[$userid][$forum->id])) {

                    self::$forumdiscussioncache[$userid][$forum->id] = array();

                }

            }

            // Reset the cache for this forum.

            self::$forumcache[$userid][$forum->id] = false;

            $context = forum_get_context($forum->id, $context);

            $params = array(

                'context' => $context,

                'objectid' => $forumsubscription->id,

                'relateduserid' => $userid,

                'other' => array('forumid' => $forum->id),

            );

            $event = event\subscription_deleted::create($params);

            $event->add_record_snapshot('forum_subscriptions', $forumsubscription);

            if ($userrequest && $discussionsubscriptions) {

                foreach ($discussionsubscriptions as $subscription) {

                    $event->add_record_snapshot('forum_discussion_subs', $subscription);

                }

                $discussionsubscriptions->close();

            }

            $event->trigger();

        }

        return true;

    }

    /**

     * Subscribes the user to the specified discussion.

     *

     * @param int $userid The userid of the user being subscribed

     * @param \stdClass $discussion The discussion to subscribe to

     * @param \context_module|null $context Module context, may be omitted if not known or if called for the current

     *     module set in page.

     * @return boolean Whether a change was made

     */

    public static function subscribe_user_to_discussion($userid, $discussion, $context = null) {

        global $DB;

        // First check whether the user is subscribed to the discussion already.

        $subscription = $DB->get_record('forum_discussion_subs', array('userid' => $userid, 'discussion' => $discussion->id));

        if ($subscription) {

            if ($subscription->preference != self::FORUM_DISCUSSION_UNSUBSCRIBED) {

                // The user is already subscribed to the discussion. Ignore.

                return false;

            }

        }

        // No discussion-level subscription. Check for a forum level subscription.

        if ($DB->record_exists('forum_subscriptions', array('userid' => $userid, 'forum' => $discussion->forum))) {

            if ($subscription && $subscription->preference == self::FORUM_DISCUSSION_UNSUBSCRIBED) {

                // The user is subscribed to the forum, but unsubscribed from the discussion, delete the discussion preference.

                $DB->delete_records('forum_discussion_subs', array('id' => $subscription->id));

                unset(self::$forumdiscussioncache[$userid][$discussion->forum][$discussion->id]);

            } else {

                // The user is already subscribed to the forum. Ignore.

                return false;

            }

        } else {

            if ($subscription) {

                $subscription->preference = time();

                $DB->update_record('forum_discussion_subs', $subscription);

            } else {

                $subscription = new \stdClass();

                $subscription->userid  = $userid;

                $subscription->forum = $discussion->forum;

                $subscription->discussion = $discussion->id;

                $subscription->preference = time();

                $subscription->id = $DB->insert_record('forum_discussion_subs', $subscription);

                self::$forumdiscussioncache[$userid][$discussion->forum][$discussion->id] = $subscription->preference;

            }

        }

        $context = forum_get_context($discussion->forum, $context);

        $params = array(

            'context' => $context,

            'objectid' => $subscription->id,

            'relateduserid' => $userid,

            'other' => array(

                'forumid' => $discussion->forum,

                'discussion' => $discussion->id,

            ),

        );

        $event  = event\discussion_subscription_created::create($params);

        $event->trigger();

        return true;

    }

    /**

     * Unsubscribes the user from the specified discussion.

     *

     * @param int $userid The userid of the user being unsubscribed

     * @param \stdClass $discussion The discussion to unsubscribe from

     * @param \context_module|null $context Module context, may be omitted if not known or if called for the current

     *     module set in page.

     * @return boolean Whether a change was made

     */

    public static function unsubscribe_user_from_discussion($userid, $discussion, $context = null) {

        global $DB;

        // First check whether the user's subscription preference for this discussion.

        $subscription = $DB->get_record('forum_discussion_subs', array('userid' => $userid, 'discussion' => $discussion->id));

        if ($subscription) {

            if ($subscription->preference == self::FORUM_DISCUSSION_UNSUBSCRIBED) {

                // The user is already unsubscribed from the discussion. Ignore.

                return false;

            }

        }

        // No discussion-level preference. Check for a forum level subscription.

        if (!$DB->record_exists('forum_subscriptions', array('userid' => $userid, 'forum' => $discussion->forum))) {

            if ($subscription && $subscription->preference != self::FORUM_DISCUSSION_UNSUBSCRIBED) {

                // The user is not subscribed to the forum, but subscribed from the discussion, delete the discussion subscription.

                $DB->delete_records('forum_discussion_subs', array('id' => $subscription->id));

                unset(self::$forumdiscussioncache[$userid][$discussion->forum][$discussion->id]);

            } else {

                // The user is not subscribed from the forum. Ignore.

                return false;

            }

        } else {

            if ($subscription) {

                $subscription->preference = self::FORUM_DISCUSSION_UNSUBSCRIBED;

                $DB->update_record('forum_discussion_subs', $subscription);

            } else {

                $subscription = new \stdClass();

                $subscription->userid  = $userid;

                $subscription->forum = $discussion->forum;

                $subscription->discussion = $discussion->id;

                $subscription->preference = self::FORUM_DISCUSSION_UNSUBSCRIBED;

                $subscription->id = $DB->insert_record('forum_discussion_subs', $subscription);

            }

            self::$forumdiscussioncache[$userid][$discussion->forum][$discussion->id] = $subscription->preference;

        }

        $context = forum_get_context($discussion->forum, $context);

        $params = array(

            'context' => $context,

            'objectid' => $subscription->id,

            'relateduserid' => $userid,

            'other' => array(

                'forumid' => $discussion->forum,

                'discussion' => $discussion->id,

            ),

        );

        $event  = event\discussion_subscription_deleted::create($params);

        $event->trigger();

        return true;

    }

    /**

     * Gets the default subscription value for the logged in user.

     *

     * @param \stdClass $forum The forum record

     * @param \context $context The course context

     * @param \cm_info $cm cm_info

     * @param int|null $discussionid The discussion we are checking against

     * @return bool Default subscription

     * @throws coding_exception

     */

    public static function get_user_default_subscription($forum, $context, $cm, ?int $discussionid) {

        global $USER;

        $manageactivities = has_capability('moodle/course:manageactivities', $context);

        if (\mod_forum\subscriptions::subscription_disabled($forum) && !$manageactivities) {

            // User does not have permission to subscribe to this discussion at all.

            $discussionsubscribe = false;

        } else if (\mod_forum\subscriptions::is_forcesubscribed($forum)) {

            // User does not have permission to unsubscribe from this discussion at all.

            $discussionsubscribe = true;

        } else {

            if (isset($discussionid) && self::is_subscribed($USER->id, $forum, $discussionid, $cm)) {

                // User is subscribed to the discussion - continue the subscription.

                $discussionsubscribe = true;

            } else if (!isset($discussionid) && \mod_forum\subscriptions::is_subscribed($USER->id, $forum, null, $cm)) {

                // Starting a new discussion, and the user is subscribed to the forum - subscribe to the discussion.

                $discussionsubscribe = true;

            } else {

                // User is not subscribed to either forum or discussion. Follow user preference.

                $discussionsubscribe = $USER->autosubscribe ?? false;

            }

        }

        return $discussionsubscribe;

    }

}