moodle/message/classes/privacy/provider.php

<?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/>.

/**
 * Privacy Subsystem implementation for core_message.
 *
 * @package    core_message
 * @category   privacy
 * @copyright  2018 Mark Nelson <markn@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
namespace core_message\privacy;

use core_privacy\local\metadata\collection;
use core_privacy\local\request\approved_contextlist;
use core_privacy\local\request\approved_userlist;
use core_privacy\local\request\contextlist;
use core_privacy\local\request\transform;
use core_privacy\local\request\userlist;
use core_privacy\local\request\writer;

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

/**
 * Privacy Subsystem implementation for core_message.
 *
 * @copyright  2018 Mark Nelson <markn@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class provider implements
    // The messaging subsystem contains data.
    \core_privacy\local\metadata\provider,

    // The messaging subsystem provides all the messages at user context - i.e. individual ones.
    \core_privacy\local\request\subsystem\provider,

    // This plugin has some sitewide user preferences to export.
    \core_privacy\local\request\user_preference_provider,

    // This plugin is capable of determining which users have data within it.
    \core_privacy\local\request\core_userlist_provider,

    // The messaging subsystem provides a data service to other components.
    \core_privacy\local\request\subsystem\plugin_provider {

    /**
     * Return the fields which contain personal data.
     *
     * @param collection $items a reference to the collection to use to store the metadata.
     * @return collection the updated collection of metadata items.
     */
    public static function get_metadata(collection $items) : collection {
        $items->add_database_table(
            'messages',
            [
                'useridfrom' => 'privacy:metadata:messages:useridfrom',
                'conversationid' => 'privacy:metadata:messages:conversationid',
                'subject' => 'privacy:metadata:messages:subject',
                'fullmessage' => 'privacy:metadata:messages:fullmessage',
                'fullmessageformat' => 'privacy:metadata:messages:fullmessageformat',
                'fullmessagehtml' => 'privacy:metadata:messages:fullmessagehtml',
                'smallmessage' => 'privacy:metadata:messages:smallmessage',
                'timecreated' => 'privacy:metadata:messages:timecreated',
                'customdata' => 'privacy:metadata:messages:customdata',
            ],
            'privacy:metadata:messages'
        );

        $items->add_database_table(
            'message_user_actions',
            [
                'userid' => 'privacy:metadata:message_user_actions:userid',
                'messageid' => 'privacy:metadata:message_user_actions:messageid',
                'action' => 'privacy:metadata:message_user_actions:action',
                'timecreated' => 'privacy:metadata:message_user_actions:timecreated'
            ],
            'privacy:metadata:message_user_actions'
        );

        $items->add_database_table(
            'message_conversation_members',
            [
                'conversationid' => 'privacy:metadata:message_conversation_members:conversationid',
                'userid' => 'privacy:metadata:message_conversation_members:userid',
                'timecreated' => 'privacy:metadata:message_conversation_members:timecreated',
            ],
            'privacy:metadata:message_conversation_members'
        );

        $items->add_database_table(
            'message_conversation_actions',
            [
                'conversationid' => 'privacy:metadata:message_conversation_actions:conversationid',
                'userid' => 'privacy:metadata:message_conversation_actions:userid',
                'timecreated' => 'privacy:metadata:message_conversation_actions:timecreated',
            ],
            'privacy:metadata:message_conversation_actions'
        );

        $items->add_database_table(
            'message_contacts',
            [
                'userid' => 'privacy:metadata:message_contacts:userid',
                'contactid' => 'privacy:metadata:message_contacts:contactid',
                'timecreated' => 'privacy:metadata:message_contacts:timecreated',
            ],
            'privacy:metadata:message_contacts'
        );

        $items->add_database_table(
            'message_contact_requests',
            [
                'userid' => 'privacy:metadata:message_contact_requests:userid',
                'requesteduserid' => 'privacy:metadata:message_contact_requests:requesteduserid',
                'timecreated' => 'privacy:metadata:message_contact_requests:timecreated',
            ],
            'privacy:metadata:message_contact_requests'
        );

        $items->add_database_table(
            'message_users_blocked',
            [
                'userid' => 'privacy:metadata:message_users_blocked:userid',
                'blockeduserid' => 'privacy:metadata:message_users_blocked:blockeduserid',
                'timecreated' => 'privacy:metadata:message_users_blocked:timecreated',
            ],
            'privacy:metadata:message_users_blocked'
        );

        $items->add_database_table(
            'notifications',
            [
                'useridfrom' => 'privacy:metadata:notifications:useridfrom',
                'useridto' => 'privacy:metadata:notifications:useridto',
                'subject' => 'privacy:metadata:notifications:subject',
                'fullmessage' => 'privacy:metadata:notifications:fullmessage',
                'fullmessageformat' => 'privacy:metadata:notifications:fullmessageformat',
                'fullmessagehtml' => 'privacy:metadata:notifications:fullmessagehtml',
                'smallmessage' => 'privacy:metadata:notifications:smallmessage',
                'component' => 'privacy:metadata:notifications:component',
                'eventtype' => 'privacy:metadata:notifications:eventtype',
                'contexturl' => 'privacy:metadata:notifications:contexturl',
                'contexturlname' => 'privacy:metadata:notifications:contexturlname',
                'timeread' => 'privacy:metadata:notifications:timeread',
                'timecreated' => 'privacy:metadata:notifications:timecreated',
                'customdata' => 'privacy:metadata:notifications:customdata',
            ],
            'privacy:metadata:notifications'
        );

        // Note - we are not adding the 'message' and 'message_read' tables
        // as they are legacy tables. This information is moved to these
        // new tables in a separate ad-hoc task. See MDL-61255.

        // Now add that we also have user preferences.
        $items->add_user_preference('core_message_messageprovider_settings',
            'privacy:metadata:preference:core_message_settings');

        // Add favourite conversations.
        $items->link_subsystem('core_favourites', 'privacy:metadata:core_favourites');

        return $items;
    }

    /**
     * Store all user preferences for core message.
     *
     * @param  int $userid The userid of the user whose data is to be exported.
     */
    public static function export_user_preferences(int $userid) {
        $preferences = get_user_preferences(null, null, $userid);
        foreach ($preferences as $name => $value) {
            if (
                (substr($name, 0, 16) == 'message_provider') ||
                ($name == 'message_blocknoncontacts') ||
                ($name == 'message_entertosend')
            ) {
                writer::export_user_preference(
                    'core_message',
                    $name,
                    $value,
                    get_string('privacy:request:preference:set', 'core_message', (object) [
                        'name' => $name,
                        'value' => $value,
                    ])
                );
            }
        }
    }

    /**
     * Get the list of contexts that contain user information for the specified user.
     *
     * @param int $userid the userid.
     * @return contextlist the list of contexts containing user info for the user.
     */
    public static function get_contexts_for_userid(int $userid) : contextlist {
        global $DB;

        $contextlist = new contextlist();

        // Messages are in the user context.
        // For the sake of performance, there is no need to call add_from_sql for each of the below cases.
        // It is enough to add the user's context as soon as we come to the conclusion that the user has some data.
        // Also, the order of checking is sorted by the probability of occurrence (just by guess).
        // There is no need to check the message_user_actions table, as there needs to be a message in order to be a message action.
        // There is no need to check the message_conversation_actions table, as there needs to be a conversation in order to
        // be a conversation action.
        // So, checking messages table would suffice.

        $hasdata = false;
        $hasdata = $hasdata || $DB->record_exists_select('notifications', 'useridfrom = ? OR useridto = ?', [$userid, $userid]);
        $sql = "SELECT mc.id
              FROM {message_conversations} mc
              JOIN {message_conversation_members} mcm
                ON (mcm.conversationid = mc.id AND mcm.userid = :userid)
             WHERE mc.contextid IS NULL";
        $hasdata = $hasdata || $DB->record_exists_sql($sql, ['userid' => $userid]);
        $sql = "SELECT mc.id
              FROM {message_conversations} mc
              JOIN {messages} m
                ON (m.conversationid = mc.id AND m.useridfrom = :useridfrom)
             WHERE mc.contextid IS NULL";
        $hasdata = $hasdata || $DB->record_exists_sql($sql, ['useridfrom' => $userid]);
        $hasdata = $hasdata || $DB->record_exists_select('message_contacts', 'userid = ? OR contactid = ?', [$userid, $userid]);
        $hasdata = $hasdata || $DB->record_exists_select('message_users_blocked', 'userid = ? OR blockeduserid = ?',
                [$userid, $userid]);
        $hasdata = $hasdata || $DB->record_exists_select('message_contact_requests', 'userid = ? OR requesteduserid = ?',
                [$userid, $userid]);

        if ($hasdata) {
            $contextlist->add_user_context($userid);
        }

        // Add favourite conversations.
        \core_favourites\privacy\provider::add_contexts_for_userid($contextlist, $userid, 'core_message', 'message_conversations');

        return $contextlist;
    }

    /**
     * Get the list of users who have data within a context.
     *
     * @param   userlist    $userlist   The userlist containing the list of users who have data in this context/plugin combination.
     */
    public static function get_users_in_context(userlist $userlist) {
        global $DB;

        $context = $userlist->get_context();

        if (!$context instanceof \context_user) {
            return;
        }

        $userid = $context->instanceid;

        // Messages are in the user context.
        // For the sake of performance, there is no need to call add_from_sql for each of the below cases.
        // It is enough to add the user's context as soon as we come to the conclusion that the user has some data.
        // Also, the order of checking is sorted by the probability of occurrence (just by guess).
        // There is no need to check the message_user_actions table, as there needs to be a message in order to be a message action.
        // There is no need to check the message_conversation_actions table, as there needs to be a conversation in order to
        // be a conversation action.
        // So, checking messages table would suffice.

        $hasdata = false;
        $hasdata = $hasdata || $DB->record_exists_select('notifications', 'useridfrom = ? OR useridto = ?', [$userid, $userid]);
        $sql = "SELECT mc.id
              FROM {message_conversations} mc
              JOIN {message_conversation_members} mcm
                ON (mcm.conversationid = mc.id AND mcm.userid = :userid)
             WHERE mc.contextid IS NULL";
        $hasdata = $hasdata || $DB->record_exists_sql($sql, ['userid' => $userid]);
        $sql = "SELECT mc.id
              FROM {message_conversations} mc
              JOIN {messages} m
                ON (m.conversationid = mc.id AND m.useridfrom = :useridfrom)
             WHERE mc.contextid IS NULL";
        $hasdata = $hasdata || $DB->record_exists_sql($sql, ['useridfrom' => $userid]);
        $hasdata = $hasdata || $DB->record_exists_select('message_contacts', 'userid = ? OR contactid = ?', [$userid, $userid]);
        $hasdata = $hasdata || $DB->record_exists_select('message_users_blocked', 'userid = ? OR blockeduserid = ?',
                        [$userid, $userid]);
        $hasdata = $hasdata || $DB->record_exists_select('message_contact_requests', 'userid = ? OR requesteduserid = ?',
                        [$userid, $userid]);

        if ($hasdata) {
            $userlist->add_user($userid);
        }

        // Add favourite conversations.
        $component = $userlist->get_component();
        if ($component != 'core_message') {
            $userlist->set_component('core_message');
        }
        \core_favourites\privacy\provider::add_userids_for_context($userlist, 'message_conversations');
        if ($component != 'core_message') {
            $userlist->set_component($component);
        }
    }

    /**
     * Export personal data for the given approved_contextlist. User and context information is contained within the contextlist.
     *
     * @param approved_contextlist $contextlist a list of contexts approved for export.
     */
    public static function export_user_data(approved_contextlist $contextlist) {
        if (empty($contextlist->count())) {
            return;
        }

        $userid = $contextlist->get_user()->id;

        // Remove non-user and invalid contexts. If it ends up empty then early return.
        $contexts = array_filter($contextlist->get_contexts(), function($context) use($userid) {
            return $context->contextlevel == CONTEXT_USER && $context->instanceid == $userid;
        });

        if (empty($contexts)) {
            return;
        }

        // Export the contacts.
        self::export_user_data_contacts($userid);

        // Export the contact requests.
        self::export_user_data_contact_requests($userid);

        // Export the blocked users.
        self::export_user_data_blocked_users($userid);

        // Export the notifications.
        self::export_user_data_notifications($userid);

        // Conversations with empty contextid should be exported here because they are not related to any component/itemid.
        $context = reset($contexts);
        self::export_conversations($userid, '', '', $context);
    }

    /**
     * Delete all data for all users in the specified context.
     *
     * @param \context $context the context to delete in.
     */
    public static function delete_data_for_all_users_in_context(\context $context) {
        if ($context instanceof \context_user) {
            static::delete_user_data($context->instanceid);
        }
    }

    /**
     * Delete all user data for the specified user, in the specified contexts.
     *
     * @param approved_contextlist $contextlist a list of contexts approved for deletion.
     */
    public static function delete_data_for_user(approved_contextlist $contextlist) {
        if (empty($contextlist->count())) {
            return;
        }

        $userid = $contextlist->get_user()->id;

        // Remove non-user and invalid contexts. If it ends up empty then early return.
        $contexts = array_filter($contextlist->get_contexts(), function($context) use($userid) {
            return $context->contextlevel == CONTEXT_USER && $context->instanceid == $userid;
        });

        if (empty($contexts)) {
            return;
        }

        static::delete_user_data($userid);
    }

    /**
     * Delete multiple users within a single context.
     *
     * @param   approved_userlist       $userlist The approved context and user information to delete information for.
     */
    public static function delete_data_for_users(approved_userlist $userlist) {
        $context = $userlist->get_context();

        if (!$context instanceof \context_user) {
            return;
        }

        // Remove invalid users. If it ends up empty then early return.
        $userids = array_filter($userlist->get_userids(), function($userid) use($context) {
            return $context->instanceid == $userid;
        });

        if (empty($userids)) {
            return;
        }

        static::delete_user_data($context->instanceid);
    }

    /**
     * Provide a list of contexts which have conversations for the user, in the respective area (component/itemtype combination).
     *
     * This method is to be called by consumers of the messaging subsystem (plugins), in their get_contexts_for_userid() method,
     * to add the contexts for items which may have any conversation, but would normally not be reported as having user data by the
     * plugin responsible for them.
     *
     * @param contextlist $contextlist
     * @param int $userid The id of the user in scope.
     * @param string $component the frankenstyle component name.
     * @param string $itemtype the type of the conversation items.
     * @param int $itemid Optional itemid associated with component.
     */
    public static function add_contexts_for_conversations(contextlist $contextlist, int $userid, string $component,
                                                          string $itemtype, int $itemid = 0) {
        // Search for conversations for this user in this area.
        $sql = "SELECT mc.contextid
                  FROM {message_conversations} mc
                  JOIN {message_conversation_members} mcm
                    ON (mcm.conversationid = mc.id AND mcm.userid = :userid)
                  JOIN {context} ctx
                    ON mc.contextid = ctx.id
                 WHERE mc.component = :component AND mc.itemtype = :itemtype";
        $params = [
            'userid' => $userid,
            'component' => $component,
            'itemtype' => $itemtype,
        ];

        if (!empty($itemid)) {
            $sql .= " AND itemid = :itemid";
            $params['itemid'] = $itemid;
        }

        $contextlist->add_from_sql($sql, $params);

        // Add favourite conversations. We don't need to filter by itemid because for now they are in the system context.
        \core_favourites\privacy\provider::add_contexts_for_userid($contextlist, $userid, 'core_message', 'message_conversations');

    }

    /**
     * Add the list of users who have a conversation in the specified area (component + itemtype + itemid).
     *
     * @param userlist $userlist The userlist to add the users to.
     * @param string $component The component to check.
     * @param string $itemtype The type of the conversation items.
     * @param int $itemid Optional itemid associated with component.
     */
    public static function add_conversations_in_context(userlist $userlist, string $component, string $itemtype, int $itemid = 0) {
        $sql = "SELECT mcm.userid
                  FROM {message_conversation_members} mcm
            INNER JOIN {message_conversations} mc
                    ON mc.id = mcm.conversationid
                 WHERE mc.contextid = :contextid AND mc.component = :component AND mc.itemtype = :itemtype";
        $params = [
            'contextid' => $userlist->get_context()->id,
            'component' => $component,
            'itemtype' => $itemtype
        ];

        if (!empty($itemid)) {
            $sql .= " AND itemid = :itemid";
            $params['itemid'] = $itemid;
        }

        $userlist->add_from_sql('userid', $sql, $params);

        // Add favourite conversations.
        $component = $userlist->get_component();
        if ($component != 'core_message') {
            $userlist->set_component('core_message');
        }
        \core_favourites\privacy\provider::add_userids_for_context($userlist, 'message_conversations');
        if ($component != 'core_message') {
            $userlist->set_component($component);
        }
    }

    /**
     * Store all conversations which match the specified component, itemtype, and itemid.
     *
     * Conversations without context (for now, the private ones) are stored in '<$context> | Messages | <Other user id>'.
     * Conversations with context are stored in '<$context> | Messages | <Conversation item type> | <Conversation name>'.
     *
     * @param   int         $userid The user whose information is to be exported.
     * @param   string      $component The component to fetch data from.
     * @param   string      $itemtype The itemtype that the data was exported in within the component.
     * @param   \context    $context The context to export for.
     * @param   array       $subcontext The sub-context in which to export this data.
     * @param   int         $itemid Optional itemid associated with component.
     */
    public static function export_conversations(int $userid, string $component, string $itemtype, \context $context,
                                                array $subcontext = [], int $itemid = 0) {
        global $DB;

        // Search for conversations for this user in this area.
        $sql = "SELECT DISTINCT mc.*
                  FROM {message_conversations} mc
                  JOIN {message_conversation_members} mcm
                    ON (mcm.conversationid = mc.id AND mcm.userid = :userid)";
        $params = [
            'userid' => $userid
        ];

        // Get the conversations for the defined component and itemtype.
        if (!empty($component) && !empty($itemtype)) {
            $sql .= " WHERE mc.component = :component AND mc.itemtype = :itemtype";
            $params['component'] = $component;
            $params['itemtype'] = $itemtype;
            if (!empty($itemid)) {
                $sql .= " AND mc.itemid = :itemid";
                $params['itemid'] = $itemid;
            }
        } else {
            // Get all the conversations without any component and itemtype, so with null contextid.
            $sql .= " WHERE mc.contextid IS NULL";
        }

        if ($conversations = $DB->get_records_sql($sql, $params)) {
            // Export conversation messages.
            foreach ($conversations as $conversation) {
                self::export_user_data_conversation_messages($userid, $conversation, $context, $subcontext);
            }
        }
    }

    /**
     * Deletes all group memberships for a specified context and component.
     *
     * @param \context  $context    Details about which context to delete group memberships for.
     * @param string    $component  The component to delete. Empty string means no component.
     * @param string    $itemtype   The itemtype of the component to delele. Empty string means no itemtype.
     * @param int       $itemid     Optional itemid associated with component.
     */
    public static function delete_conversations_for_all_users(\context $context, string $component, string $itemtype,
                                                              int $itemid = 0) {
        global $DB;

        if (empty($context)) {
            return;
        }

        $select = "contextid = :contextid AND component = :component AND itemtype = :itemtype";
        $params = [
            'contextid' => $context->id,
            'component' => $component,
            'itemtype' => $itemtype
        ];

        if (!empty($itemid)) {
            $select .= " AND itemid = :itemid";
            $params['itemid'] = $itemid;
        }

        // Get and remove all the conversations and messages for the specified context and area.
        if ($conversationids = $DB->get_records_select('message_conversations', $select, $params, '', 'id')) {
            $conversationids = array_keys($conversationids);
            $messageids = $DB->get_records_list('messages', 'conversationid', $conversationids);
            $messageids = array_keys($messageids);

            // Delete these favourite conversations to all the users.
            foreach ($conversationids as $conversationid) {
                \core_favourites\privacy\provider::delete_favourites_for_all_users(
                    $context,
                    'core_message',
                    'message_conversations',
                    $conversationid);
            }

            // Delete messages and user_actions.
            $DB->delete_records_list('message_user_actions', 'messageid', $messageids);
            $DB->delete_records_list('messages', 'id', $messageids);

            // Delete members and conversations.
            $DB->delete_records_list('message_conversation_members', 'conversationid', $conversationids);
            $DB->delete_records_list('message_conversation_actions', 'conversationid', $conversationids);
            $DB->delete_records_list('message_conversations', 'id', $conversationids);
        }
    }

    /**
     * Deletes all records for a user from a list of approved contexts.
     *
     * When the component and the itemtype are empty and there is only one user context in the list, all the
     * conversations without contextid will be removed. However, if the component and itemtype are defined,
     * only the conversations in these area for the contexts in $contextlist wil be deleted.
     *
     * @param approved_contextlist  $contextlist    Contains the user ID and a list of contexts to be deleted from.
     * @param string    $component  The component to delete. Empty string means no component.
     * @param string    $itemtype   The itemtype of the component to delele. Empty string means no itemtype.
     * @param int       $itemid     Optional itemid associated with component.
     */
    public static function delete_conversations_for_user(approved_contextlist $contextlist, string $component, string $itemtype,
                                                         int $itemid = 0) {
        self::delete_user_data_conversations(
            $contextlist->get_user()->id,
            $contextlist->get_contextids(),
            $component,
            $itemtype,
            $itemid
        );
    }

    /**
     * Deletes all records for multiple users within a single context.
     *
     * @param approved_userlist $userlist  The approved context and user information to delete information for.
     * @param string    $component  The component to delete. Empty string means no component.
     * @param string    $itemtype   The itemtype of the component to delele. Empty string means no itemtype.
     * @param int       $itemid     Optional itemid associated with component.
     */
    public static function delete_conversations_for_users(approved_userlist $userlist, string $component, string $itemtype,
                                                          int $itemid = 0) {
        global $DB;

        $userids = $userlist->get_userids();
        if (empty($userids)) {
            return;
        }

        $context = $userlist->get_context();
        $select = "mc.contextid = :contextid AND mc.component = :component AND mc.itemtype = :itemtype";
        $params = [
            'contextid' => $context->id,
            'component' => $component,
            'itemtype' => $itemtype
        ];
        if (!empty($itemid)) {
            $select .= " AND itemid = :itemid";
            $params['itemid'] = $itemid;
        }

        // Get conversations in this area where the specified users are a member of.
        list($useridsql, $useridparams) = $DB->get_in_or_equal($userids, SQL_PARAMS_NAMED);
        $sql = "SELECT DISTINCT mcm.conversationid as id
                  FROM {message_conversation_members} mcm
            INNER JOIN {message_conversations} mc
                    ON mc.id = mcm.conversationid
                 WHERE mcm.userid $useridsql AND $select";
        $params += $useridparams;
        $conversationids = array_keys($DB->get_records_sql($sql, $params));
        if (!empty($conversationids)) {
            list($conversationidsql, $conversationidparams) = $DB->get_in_or_equal($conversationids, SQL_PARAMS_NAMED);

            // Get all the messages for these conversations which has some action stored for these users.
            $sql = "SELECT DISTINCT m.id
                      FROM {messages} m
                INNER JOIN {message_conversations} mc
                        ON mc.id = m.conversationid
                INNER JOIN {message_user_actions} mua
                        ON mua.messageid = m.id
                     WHERE mua.userid $useridsql  AND mc.id $conversationidsql";
            $params = $useridparams + $conversationidparams;
            $messageids = array_keys($DB->get_records_sql($sql, $params));
            if (!empty($messageids)) {
                // Delete all the user_actions for the messages on these conversations where the user has any action.
                list($messageidsql, $messageidparams) = $DB->get_in_or_equal($messageids, SQL_PARAMS_NAMED);
                $select = "messageid $messageidsql AND userid $useridsql";
                $DB->delete_records_select('message_user_actions', $select, $messageidparams + $useridparams);
            }

            // Get all the messages for these conversations sent by these users.
            $sql = "SELECT DISTINCT m.id
                      FROM {messages} m
                     WHERE m.useridfrom $useridsql AND m.conversationid $conversationidsql";
            // Reuse the $params var because it contains the useridparams and the conversationids.
            $messageids = array_keys($DB->get_records_sql($sql, $params));
            if (!empty($messageids)) {
                // Delete all the user_actions for the messages sent by any of these users.
                $DB->delete_records_list('message_user_actions', 'messageid', $messageids);

                // Delete all the messages sent by any of these users.
                $DB->delete_records_list('messages', 'id', $messageids);
            }

            // In that case, conversations can't be removed, because they could have more members and messages.
            // So, remove only users from the context conversations where they are member of.
            $sql = "conversationid $conversationidsql AND userid $useridsql";
            // Reuse the $params var because it contains the useridparams and the conversationids.
            $DB->delete_records_select('message_conversation_members', $sql, $params);

            // Delete any conversation actions.
            $DB->delete_records_select('message_conversation_actions', $sql, $params);

            // Delete the favourite conversations.
            $userlist = new \core_privacy\local\request\approved_userlist($context, 'core_message', $userids);
            \core_favourites\privacy\provider::delete_favourites_for_userlist(
                $userlist,
                'message_conversations'
            );
        }
    }

    /**
     * Deletes all records for multiple users within multiple contexts in a component area.
     *
     * @param  int    $userid     The user identifier to delete information for.
     * @param  array  $contextids The context identifiers to delete information for. Empty array means no context (for
     *                            individual conversations).
     * @param  string $component  The component to delete. Empty string means no component (for individual conversations).
     * @param  string $itemtype   The itemtype of the component to delele. Empty string means no itemtype (for individual
     *                            conversations).
     * @param  int    $itemid     Optional itemid associated with component.
     */
    protected static function delete_user_data_conversations(int $userid, array $contextids, string $component,
                                                            string $itemtype, int $itemid = 0) {
        global $DB;

        if (empty($contextids) && empty($component) && empty($itemtype) && empty($itemid)) {
            // Individual conversations haven't context, component neither itemtype.
            $select = "mc.contextid IS NULL";
            $params = [];
        } else {
            list($contextidsql, $contextidparams) = $DB->get_in_or_equal($contextids, SQL_PARAMS_NAMED);
            $select = "mc.contextid $contextidsql AND mc.component = :component AND mc.itemtype = :itemtype";
            $params = [
                'component' => $component,
                'itemtype' => $itemtype
            ];
            $params += $contextidparams;
            if (!empty($itemid)) {
                $select .= " AND itemid = :itemid";
                $params['itemid'] = $itemid;
            }
        }

        // Get conversations in these contexts where the specified userid is a member of.
        $sql = "SELECT DISTINCT mcm.conversationid as id
                  FROM {message_conversation_members} mcm
            INNER JOIN {message_conversations} mc
                    ON mc.id = mcm.conversationid
                 WHERE mcm.userid = :userid AND $select";
        $params['userid'] = $userid;
        $conversationids = array_keys($DB->get_records_sql($sql, $params));
        if (!empty($conversationids)) {
            list($conversationidsql, $conversationidparams) = $DB->get_in_or_equal($conversationids, SQL_PARAMS_NAMED);

            // Get all the messages for these conversations which has some action stored for the userid.
            $sql = "SELECT DISTINCT m.id
                      FROM {messages} m
                INNER JOIN {message_conversations} mc
                        ON mc.id = m.conversationid
                INNER JOIN {message_user_actions} mua
                        ON mua.messageid = m.id
                     WHERE mua.userid = :userid AND mc.id $conversationidsql";
            $params = ['userid' => $userid] + $conversationidparams;
            $messageids = array_keys($DB->get_records_sql($sql, $params));
            if (!empty($messageids)) {
                // Delete all the user_actions for the messages on these conversations where the user has any action.
                list($messageidsql, $messageidparams) = $DB->get_in_or_equal($messageids, SQL_PARAMS_NAMED);
                $select = "messageid $messageidsql AND userid = :userid";
                $DB->delete_records_select('message_user_actions', $select, $messageidparams + ['userid' => $userid]);
            }

            // Get all the messages for these conversations sent by the userid.
            $sql = "SELECT DISTINCT m.id
                      FROM {messages} m
                     WHERE m.useridfrom = :userid AND m.conversationid $conversationidsql";
            // Reuse the $params var because it contains the userid and the conversationids.
            $messageids = array_keys($DB->get_records_sql($sql, $params));
            if (!empty($messageids)) {
                // Delete all the user_actions for the messages sent by the userid.
                $DB->delete_records_list('message_user_actions', 'messageid', $messageids);

                // Delete all the messages sent by the userid.
                $DB->delete_records_list('messages', 'id', $messageids);
            }

            // In that case, conversations can't be removed, because they could have more members and messages.
            // So, remove only userid from the context conversations where he/she is member of.
            $sql = "conversationid $conversationidsql AND userid = :userid";
            // Reuse the $params var because it contains the userid and the conversationids.
            $DB->delete_records_select('message_conversation_members', $sql, $params);

            // Delete any conversation actions.
            $DB->delete_records_select('message_conversation_actions', $sql, $params);

            // Delete the favourite conversations.
            if (empty($contextids) && empty($component) && empty($itemtype) && empty($itemid)) {
                // Favourites for individual conversations are stored into the user context.
                $favouritectxids = [\context_user::instance($userid)->id];
            } else {
                $favouritectxids = $contextids;
            }
            $contextlist = new \core_privacy\local\request\approved_contextlist(
                \core_user::get_user($userid),
                'core_message',
                $favouritectxids
            );
            \core_favourites\privacy\provider::delete_favourites_for_user(
                $contextlist,
                'core_message',
                'message_conversations'
            );
        }
    }

    /**
     * Delete all user data for the specified user.
     *
     * @param int $userid The user id
     */
    protected static function delete_user_data(int $userid) {
        global $DB;

        // Delete individual conversations information for this user.
        self::delete_user_data_conversations($userid, [], '', '');

        // Delete contacts, requests, users blocked and notifications.
        $DB->delete_records_select('message_contacts', 'userid = ? OR contactid = ?', [$userid, $userid]);
        $DB->delete_records_select('message_contact_requests', 'userid = ? OR requesteduserid = ?', [$userid, $userid]);
        $DB->delete_records_select('message_users_blocked', 'userid = ? OR blockeduserid = ?', [$userid, $userid]);
        $DB->delete_records_select('notifications', 'useridfrom = ? OR useridto = ?', [$userid, $userid]);
    }

    /**
     * Export the messaging contact data.
     *
     * @param int $userid
     */
    protected static function export_user_data_contacts(int $userid) {
        global $DB;

        $context = \context_user::instance($userid);

        // Get the user's contacts.
        if ($contacts = $DB->get_records_select('message_contacts', 'userid = ? OR contactid = ?', [$userid, $userid], 'id ASC')) {
            $contactdata = [];
            foreach ($contacts as $contact) {
                $contactdata[] = (object) [
                    'contact' => transform::user($contact->contactid)
                ];
            }
            writer::with_context($context)->export_data([get_string('contacts', 'core_message')], (object) $contactdata);
        }
    }

    /**
     * Export the messaging contact requests data.
     *
     * @param int $userid
     */
    protected static function export_user_data_contact_requests(int $userid) {
        global $DB;

        $context = \context_user::instance($userid);

        if ($contactrequests = $DB->get_records_select('message_contact_requests', 'userid = ? OR requesteduserid = ?',
                [$userid, $userid], 'id ASC')) {
            $contactrequestsdata = [];
            foreach ($contactrequests as $contactrequest) {
                if ($userid == $contactrequest->requesteduserid) {
                    $maderequest = false;
                    $contactid = $contactrequest->userid;
                } else {
                    $maderequest = true;
                    $contactid = $contactrequest->requesteduserid;
                }

                $contactrequestsdata[] = (object) [
                    'contactrequest' => transform::user($contactid),
                    'maderequest' => transform::yesno($maderequest)
                ];
            }
            writer::with_context($context)->export_data([get_string('contactrequests', 'core_message')],
                (object) $contactrequestsdata);
        }
    }

    /**
     * Export the messaging blocked users data.
     *
     * @param int $userid
     */
    protected static function export_user_data_blocked_users(int $userid) {
        global $DB;

        $context = \context_user::instance($userid);

        if ($blockedusers = $DB->get_records('message_users_blocked', ['userid' => $userid], 'id ASC')) {
            $blockedusersdata = [];
            foreach ($blockedusers as $blockeduser) {
                $blockedusersdata[] = (object) [
                    'blockeduser' => transform::user($blockeduser->blockeduserid)
                ];
            }
            writer::with_context($context)->export_data([get_string('blockedusers', 'core_message')], (object) $blockedusersdata);
        }
    }

    /**
     * Export conversation messages.
     *
     * @param int $userid The user identifier.
     * @param \stdClass $conversation The conversation to export the messages.
     * @param \context $context The context to export for.
     * @param array $subcontext The sub-context in which to export this data.
     */
    protected static function export_user_data_conversation_messages(int $userid, \stdClass $conversation, \context $context,
                                                                     array $subcontext = []) {
        global $DB;

        // Get all the messages for this conversation from start to finish.
        $sql = "SELECT m.*, muadelete.timecreated as timedeleted, muaread.timecreated as timeread
                  FROM {messages} m
             LEFT JOIN {message_user_actions} muadelete
                    ON m.id = muadelete.messageid AND muadelete.action = :deleteaction AND muadelete.userid = :deleteuserid
             LEFT JOIN {message_user_actions} muaread
                    ON m.id = muaread.messageid AND muaread.action = :readaction AND muaread.userid = :readuserid
                 WHERE conversationid = :conversationid
              ORDER BY m.timecreated ASC";
        $messages = $DB->get_recordset_sql($sql, ['deleteaction' => \core_message\api::MESSAGE_ACTION_DELETED,
            'readaction' => \core_message\api::MESSAGE_ACTION_READ, 'conversationid' => $conversation->id,
            'deleteuserid' => $userid, 'readuserid' => $userid]);
        $messagedata = [];
        foreach ($messages as $message) {
            $timeread = !is_null($message->timeread) ? transform::datetime($message->timeread) : '-';
            $issender = $userid == $message->useridfrom;

            $data = [
                'issender' => transform::yesno($issender),
                'message' => message_format_message_text($message),
                'timecreated' => transform::datetime($message->timecreated),
                'timeread' => $timeread,
                'customdata' => $message->customdata,
            ];
            if ($conversation->type == \core_message\api::MESSAGE_CONVERSATION_TYPE_GROUP && !$issender) {
                // Only export sender for group conversations when is not the current user.
                $data['sender'] = transform::user($message->useridfrom);
            }

            if (!is_null($message->timedeleted)) {
                $data['timedeleted'] = transform::datetime($message->timedeleted);
            }

            $messagedata[] = (object) $data;
        }
        $messages->close();

        if (!empty($messagedata)) {
            // Get subcontext.
            if (empty($conversation->contextid)) {
                // Conversations without context are stored in 'Messages | <Other user id>'.
                if ($conversation->type == \core_message\api::MESSAGE_CONVERSATION_TYPE_SELF) {
                    // This is a self-conversation. The other user is the same userid.
                    $otherusertext = $userid;
                } else {
                    $members = $DB->get_records('message_conversation_members', ['conversationid' => $conversation->id]);
                    $members = array_filter($members, function ($member) use ($userid) {
                        return $member->userid != $userid;
                    });
                    if ($otheruser = reset($members)) {
                        $otherusertext = $otheruser->userid;
                    } else {
                        $otherusertext = get_string('unknownuser', 'core_message') . '_' . $conversation->id;
                    }
                }

                $subcontext = array_merge(
                    $subcontext,
                    [get_string('messages', 'core_message'), $otherusertext]
                );

                // Get the context for the favourite conversation.
                $conversationctx = \context_user::instance($userid);
            } else {
                // Conversations with context are stored in 'Messages | <Conversation item type> | <Conversation name>'.
                if (get_string_manager()->string_exists($conversation->itemtype, $conversation->component)) {
                    $itemtypestring = get_string($conversation->itemtype, $conversation->component);
                } else {
                    // If the itemtype doesn't exist in the component string file, the raw itemtype will be returned.
                    $itemtypestring = $conversation->itemtype;
                }

                $conversationname = get_string('privacy:export:conversationprefix', 'core_message') . $conversation->name;
                $subcontext = array_merge(
                    $subcontext,
                    [get_string('messages', 'core_message'), $itemtypestring, $conversationname]
                );

                // Get the context for the favourite conversation.
                $conversationctx = \context::instance_by_id($conversation->contextid);
            }

            // Export the conversation messages.
            writer::with_context($context)->export_data($subcontext, (object) $messagedata);

            // Get user's favourites information for the particular conversation.
            $conversationfavourite = \core_favourites\privacy\provider::get_favourites_info_for_user($userid, $conversationctx,
                'core_message', 'message_conversations', $conversation->id);
            if ($conversationfavourite) {
                // If the conversation has been favorited by the user, include it in the export.
                writer::with_context($context)->export_related_data($subcontext, 'starred', (object) $conversationfavourite);
            }

            // Check if the conversation was muted.
            $params = [
                'userid' => $userid,
                'conversationid' => $conversation->id,
                'action' => \core_message\api::CONVERSATION_ACTION_MUTED
            ];
            if ($mca = $DB->get_record('message_conversation_actions', $params)) {
                $mcatostore = [
                    'muted' => transform::yesno(true),
                    'timecreated' => transform::datetime($mca->timecreated),
                ];
                writer::with_context($context)->export_related_data($subcontext, 'muted', (object) $mcatostore);
            }
        }
    }

    /**
     * Export the notification data.
     *
     * @param int $userid
     */
    protected static function export_user_data_notifications(int $userid) {
        global $DB;

        $context = \context_user::instance($userid);

        $notificationdata = [];
        $select = "useridfrom = ? OR useridto = ?";
        $notifications = $DB->get_recordset_select('notifications', $select, [$userid, $userid], 'timecreated ASC');
        foreach ($notifications as $notification) {
            $timeread = !is_null($notification->timeread) ? transform::datetime($notification->timeread) : '-';

            $data = (object) [
                'subject' => $notification->subject,
                'fullmessage' => $notification->fullmessage,
                'smallmessage' => $notification->smallmessage,
                'component' => $notification->component,
                'eventtype' => $notification->eventtype,
                'contexturl' => $notification->contexturl,
                'contexturlname' => $notification->contexturlname,
                'timeread' => $timeread,
                'timecreated' => transform::datetime($notification->timecreated),
                'customdata' => $notification->customdata,
            ];

            $notificationdata[] = $data;
        }
        $notifications->close();

        writer::with_context($context)->export_data([get_string('notifications', 'core_message')], (object) $notificationdata);
    }
}