Your IP : 192.168.165.1
<?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/>.
/**
* Adhoc task handling migrating data to the new messaging table schema.
*
* @package core_message
* @copyright 2018 Mark Nelson <markn@moodle.com>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace core_message\task;
defined('MOODLE_INTERNAL') || die();
/**
* Class handling migrating data to the new messaging table schema.
*
* @package core_message
* @copyright 2018 Mark Nelson <markn@moodle.com>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class migrate_message_data extends \core\task\adhoc_task {
/**
* Run the migration task.
*/
public function execute() {
global $DB;
$userid = $this->get_custom_data()->userid;
// Get the user's preference.
$hasbeenmigrated = get_user_preferences('core_message_migrate_data', false, $userid);
if (!$hasbeenmigrated) {
// To determine if we should update the preference.
$updatepreference = true;
// Get all the users the current user has received a message from.
$sql = "SELECT DISTINCT(useridfrom)
FROM {message} m
WHERE useridto = ?
UNION
SELECT DISTINCT(useridfrom)
FROM {message_read} m
WHERE useridto = ?";
$users = $DB->get_records_sql($sql, [$userid, $userid]);
// Get all the users the current user has messaged.
$sql = "SELECT DISTINCT(useridto)
FROM {message} m
WHERE useridfrom = ?
UNION
SELECT DISTINCT(useridto)
FROM {message_read} m
WHERE useridfrom = ?";
$users = $users + $DB->get_records_sql($sql, [$userid, $userid]);
if (!empty($users)) {
// Loop through each user and migrate the data.
foreach ($users as $otheruserid => $user) {
$ids = [$userid, $otheruserid];
sort($ids);
$key = implode('_', $ids);
// Set the lock data.
$timeout = 5; // In seconds.
$locktype = 'core_message_migrate_data';
// Get an instance of the currently configured lock factory.
$lockfactory = \core\lock\lock_config::get_lock_factory($locktype);
// See if we can grab this lock.
if ($lock = $lockfactory->get_lock($key, $timeout)) {
try {
$transaction = $DB->start_delegated_transaction();
$this->migrate_data($userid, $otheruserid);
$transaction->allow_commit();
} catch (\Throwable $e) {
throw $e;
} finally {
$lock->release();
}
} else {
// Couldn't get a lock, move on to next user but make sure we don't update user preference so
// we still try again.
$updatepreference = false;
continue;
}
}
}
if ($updatepreference) {
set_user_preference('core_message_migrate_data', true, $userid);
} else {
// Throwing an exception in the task will mean that it isn't removed from the queue and is tried again.
throw new \moodle_exception('Task failed.');
}
}
}
/**
* Helper function to deal with migrating the data.
*
* @param int $userid The current user id.
* @param int $otheruserid The user id of the other user in the conversation.
* @throws \dml_exception
*/
private function migrate_data($userid, $otheruserid) {
global $DB;
if ($userid == $otheruserid) {
// Since 3.7, pending self-conversations should be migrated during the upgrading process so shouldn't be any
// self-conversations on the legacy tables. However, this extra-check has been added just in case.
$conversation = \core_message\api::get_self_conversation($userid);
if (empty($conversation)) {
$conversation = \core_message\api::create_conversation(
\core_message\api::MESSAGE_CONVERSATION_TYPE_SELF,
[$userid]
);
}
$conversationid = $conversation->id;
} else if (!$conversationid = \core_message\api::get_conversation_between_users([$userid, $otheruserid])) {
$conversation = \core_message\api::create_conversation(
\core_message\api::MESSAGE_CONVERSATION_TYPE_INDIVIDUAL,
[
$userid,
$otheruserid
]
);
$conversationid = $conversation->id;
}
// First, get the rows from the 'message' table.
$select = "(useridfrom = ? AND useridto = ?) OR (useridfrom = ? AND useridto = ?)";
$params = [$userid, $otheruserid, $otheruserid, $userid];
$messages = $DB->get_recordset_select('message', $select, $params, 'id ASC');
foreach ($messages as $message) {
if ($message->notification) {
$this->migrate_notification($message, false);
} else {
$this->migrate_message($conversationid, $message);
}
}
$messages->close();
// Ok, all done, delete the records from the 'message' table.
$DB->delete_records_select('message', $select, $params);
// Now, get the rows from the 'message_read' table.
$messages = $DB->get_recordset_select('message_read', $select, $params, 'id ASC');
foreach ($messages as $message) {
if ($message->notification) {
$this->migrate_notification($message, true);
} else {
$this->migrate_message($conversationid, $message);
}
}
$messages->close();
// Ok, all done, delete the records from the 'message_read' table.
$DB->delete_records_select('message_read', $select, $params);
}
/**
* Helper function to deal with migrating an individual notification.
*
* @param \stdClass $notification
* @param bool $isread Was the notification read?
* @throws \dml_exception
*/
private function migrate_notification($notification, $isread) {
global $DB;
$tabledata = new \stdClass();
$tabledata->useridfrom = $notification->useridfrom;
$tabledata->useridto = $notification->useridto;
$tabledata->subject = $notification->subject;
$tabledata->fullmessage = $notification->fullmessage;
$tabledata->fullmessageformat = $notification->fullmessageformat ?? FORMAT_MOODLE;
$tabledata->fullmessagehtml = $notification->fullmessagehtml;
$tabledata->smallmessage = $notification->smallmessage;
$tabledata->component = $notification->component;
$tabledata->eventtype = $notification->eventtype;
$tabledata->contexturl = $notification->contexturl;
$tabledata->contexturlname = $notification->contexturlname;
$tabledata->timeread = $notification->timeread ?? null;
$tabledata->timecreated = $notification->timecreated;
$newid = $DB->insert_record('notifications', $tabledata);
// Check if there is a record to move to the new 'message_popup_notifications' table.
if ($mp = $DB->get_record('message_popup', ['messageid' => $notification->id, 'isread' => (int) $isread])) {
$mpn = new \stdClass();
$mpn->notificationid = $newid;
$DB->insert_record('message_popup_notifications', $mpn);
$DB->delete_records('message_popup', ['id' => $mp->id]);
}
}
/**
* Helper function to deal with migrating an individual message.
*
* @param int $conversationid The conversation between the two users.
* @param \stdClass $message The message from either the 'message' or 'message_read' table
* @throws \dml_exception
*/
private function migrate_message($conversationid, $message) {
global $DB;
// Create the object we will be inserting into the database.
$tabledata = new \stdClass();
$tabledata->useridfrom = $message->useridfrom;
$tabledata->conversationid = $conversationid;
$tabledata->subject = $message->subject;
$tabledata->fullmessage = $message->fullmessage;
$tabledata->fullmessageformat = $message->fullmessageformat ?? FORMAT_MOODLE;
$tabledata->fullmessagehtml = $message->fullmessagehtml;
$tabledata->smallmessage = $message->smallmessage;
$tabledata->timecreated = $message->timecreated;
$messageid = $DB->insert_record('messages', $tabledata);
// Check if we need to mark this message as deleted for the user from.
if ($message->timeuserfromdeleted) {
$mua = new \stdClass();
$mua->userid = $message->useridfrom;
$mua->messageid = $messageid;
$mua->action = \core_message\api::MESSAGE_ACTION_DELETED;
$mua->timecreated = $message->timeuserfromdeleted;
$DB->insert_record('message_user_actions', $mua);
}
// Check if we need to mark this message as deleted for the user to.
if ($message->timeusertodeleted and ($message->useridfrom != $message->useridto)) {
$mua = new \stdClass();
$mua->userid = $message->useridto;
$mua->messageid = $messageid;
$mua->action = \core_message\api::MESSAGE_ACTION_DELETED;
$mua->timecreated = $message->timeusertodeleted;
$DB->insert_record('message_user_actions', $mua);
}
// Check if we need to mark this message as read for the user to (it is always read by the user from).
// Note - we do an isset() check here because this column only exists in the 'message_read' table.
if (isset($message->timeread)) {
$mua = new \stdClass();
$mua->userid = $message->useridto;
$mua->messageid = $messageid;
$mua->action = \core_message\api::MESSAGE_ACTION_READ;
$mua->timecreated = $message->timeread;
$DB->insert_record('message_user_actions', $mua);
}
}
/**
* Queues the task.
*
* @param int $userid
*/
public static function queue_task($userid) {
// Let's set up the adhoc task.
$task = new \core_message\task\migrate_message_data();
$task->set_custom_data(
[
'userid' => $userid
]
);
// Queue it.
\core\task\manager::queue_adhoc_task($task, true);
}
}