mirror of
https://github.com/moodle/moodle.git
synced 2025-02-12 11:32:04 +01:00
c75559cfff
Fix some of the behat tests that are looking for generic button names that match some of the buttons in the message drawer which happen to appear earlier in the DOM.
916 lines
35 KiB
PHP
916 lines
35 KiB
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/>.
|
|
|
|
/**
|
|
* Library functions for messaging
|
|
*
|
|
* @package core_message
|
|
* @copyright 2008 Luis Rodrigues
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
define('MESSAGE_SHORTLENGTH', 300);
|
|
|
|
define('MESSAGE_HISTORY_ALL', 1);
|
|
|
|
define('MESSAGE_SEARCH_MAX_RESULTS', 200);
|
|
|
|
define('MESSAGE_TYPE_NOTIFICATION', 'notification');
|
|
define('MESSAGE_TYPE_MESSAGE', 'message');
|
|
|
|
/**
|
|
* Define contants for messaging default settings population. For unambiguity of
|
|
* plugin developer intentions we use 4-bit value (LSB numbering):
|
|
* bit 0 - whether to send message when user is loggedin (MESSAGE_DEFAULT_LOGGEDIN)
|
|
* bit 1 - whether to send message when user is loggedoff (MESSAGE_DEFAULT_LOGGEDOFF)
|
|
* bit 2..3 - messaging permission (MESSAGE_DISALLOWED|MESSAGE_PERMITTED|MESSAGE_FORCED)
|
|
*
|
|
* MESSAGE_PERMITTED_MASK contains the mask we use to distinguish permission setting
|
|
*/
|
|
|
|
define('MESSAGE_DEFAULT_LOGGEDIN', 0x01); // 0001
|
|
define('MESSAGE_DEFAULT_LOGGEDOFF', 0x02); // 0010
|
|
|
|
define('MESSAGE_DISALLOWED', 0x04); // 0100
|
|
define('MESSAGE_PERMITTED', 0x08); // 1000
|
|
define('MESSAGE_FORCED', 0x0c); // 1100
|
|
|
|
define('MESSAGE_PERMITTED_MASK', 0x0c); // 1100
|
|
|
|
/**
|
|
* Set default value for default outputs permitted setting
|
|
*/
|
|
define('MESSAGE_DEFAULT_PERMITTED', 'permitted');
|
|
|
|
/**
|
|
* Set default values for polling.
|
|
*/
|
|
define('MESSAGE_DEFAULT_MIN_POLL_IN_SECONDS', 10);
|
|
define('MESSAGE_DEFAULT_MAX_POLL_IN_SECONDS', 2 * MINSECS);
|
|
define('MESSAGE_DEFAULT_TIMEOUT_POLL_IN_SECONDS', 5 * MINSECS);
|
|
|
|
/**
|
|
* Returns the count of unread messages for user. Either from a specific user or from all users.
|
|
*
|
|
* @param object $user1 the first user. Defaults to $USER
|
|
* @param object $user2 the second user. If null this function will count all of user 1's unread messages.
|
|
* @return int the count of $user1's unread messages
|
|
*/
|
|
function message_count_unread_messages($user1=null, $user2=null) {
|
|
global $USER, $DB;
|
|
|
|
if (empty($user1)) {
|
|
$user1 = $USER;
|
|
}
|
|
|
|
$sql = "SELECT COUNT(m.id)
|
|
FROM {messages} m
|
|
INNER JOIN {message_conversations} mc
|
|
ON mc.id = m.conversationid
|
|
INNER JOIN {message_conversation_members} mcm
|
|
ON mcm.conversationid = mc.id
|
|
LEFT JOIN {message_user_actions} mua
|
|
ON (mua.messageid = m.id AND mua.userid = ? AND (mua.action = ? OR mua.action = ?))
|
|
WHERE mua.id is NULL
|
|
AND mcm.userid = ?";
|
|
$params = [$user1->id, \core_message\api::MESSAGE_ACTION_DELETED, \core_message\api::MESSAGE_ACTION_READ, $user1->id];
|
|
|
|
if (!empty($user2)) {
|
|
$sql .= " AND m.useridfrom = ?";
|
|
$params[] = $user2->id;
|
|
} else {
|
|
$sql .= " AND m.useridfrom <> ?";
|
|
$params[] = $user1->id;
|
|
}
|
|
|
|
return $DB->count_records_sql($sql, $params);
|
|
}
|
|
|
|
/**
|
|
* Try to guess how to convert the message to html.
|
|
*
|
|
* @access private
|
|
*
|
|
* @param stdClass $message
|
|
* @param bool $forcetexttohtml
|
|
* @return string html fragment
|
|
*/
|
|
function message_format_message_text($message, $forcetexttohtml = false) {
|
|
// Note: this is a very nasty hack that tries to work around the weird messaging rules and design.
|
|
|
|
$options = new stdClass();
|
|
$options->para = false;
|
|
$options->blanktarget = true;
|
|
|
|
$format = $message->fullmessageformat;
|
|
|
|
if (strval($message->smallmessage) !== '') {
|
|
if (!empty($message->notification)) {
|
|
if (strval($message->fullmessagehtml) !== '' or strval($message->fullmessage) !== '') {
|
|
$format = FORMAT_PLAIN;
|
|
}
|
|
}
|
|
$messagetext = $message->smallmessage;
|
|
|
|
} else if ($message->fullmessageformat == FORMAT_HTML) {
|
|
if (strval($message->fullmessagehtml) !== '') {
|
|
$messagetext = $message->fullmessagehtml;
|
|
} else {
|
|
$messagetext = $message->fullmessage;
|
|
$format = FORMAT_MOODLE;
|
|
}
|
|
|
|
} else {
|
|
if (strval($message->fullmessage) !== '') {
|
|
$messagetext = $message->fullmessage;
|
|
} else {
|
|
$messagetext = $message->fullmessagehtml;
|
|
$format = FORMAT_HTML;
|
|
}
|
|
}
|
|
|
|
if ($forcetexttohtml) {
|
|
// This is a crazy hack, why not set proper format when creating the notifications?
|
|
if ($format === FORMAT_PLAIN) {
|
|
$format = FORMAT_MOODLE;
|
|
}
|
|
}
|
|
return format_text($messagetext, $format, $options);
|
|
}
|
|
|
|
/**
|
|
* Search through course users.
|
|
*
|
|
* If $courseids contains the site course then this function searches
|
|
* through all undeleted and confirmed users.
|
|
*
|
|
* @param int|array $courseids Course ID or array of course IDs.
|
|
* @param string $searchtext the text to search for.
|
|
* @param string $sort the column name to order by.
|
|
* @param string|array $exceptions comma separated list or array of user IDs to exclude.
|
|
* @return array An array of {@link $USER} records.
|
|
*/
|
|
function message_search_users($courseids, $searchtext, $sort='', $exceptions='') {
|
|
global $CFG, $USER, $DB;
|
|
|
|
// Basic validation to ensure that the parameter $courseids is not an empty array or an empty value.
|
|
if (!$courseids) {
|
|
$courseids = array(SITEID);
|
|
}
|
|
|
|
// Allow an integer to be passed.
|
|
if (!is_array($courseids)) {
|
|
$courseids = array($courseids);
|
|
}
|
|
|
|
$fullname = $DB->sql_fullname();
|
|
$ufields = user_picture::fields('u');
|
|
|
|
if (!empty($sort)) {
|
|
$order = ' ORDER BY '. $sort;
|
|
} else {
|
|
$order = '';
|
|
}
|
|
|
|
$params = array(
|
|
'userid' => $USER->id,
|
|
'userid2' => $USER->id,
|
|
'query' => "%$searchtext%"
|
|
);
|
|
|
|
if (empty($exceptions)) {
|
|
$exceptions = array();
|
|
} else if (!empty($exceptions) && is_string($exceptions)) {
|
|
$exceptions = explode(',', $exceptions);
|
|
}
|
|
|
|
// Ignore self and guest account.
|
|
$exceptions[] = $USER->id;
|
|
$exceptions[] = $CFG->siteguest;
|
|
|
|
// Exclude exceptions from the search result.
|
|
list($except, $params_except) = $DB->get_in_or_equal($exceptions, SQL_PARAMS_NAMED, 'param', false);
|
|
$except = ' AND u.id ' . $except;
|
|
$params = array_merge($params_except, $params);
|
|
|
|
if (in_array(SITEID, $courseids)) {
|
|
// Search on site level.
|
|
return $DB->get_records_sql("SELECT $ufields, mc.id as contactlistid, mub.id as userblockedid
|
|
FROM {user} u
|
|
LEFT JOIN {message_contacts} mc
|
|
ON mc.contactid = u.id AND mc.userid = :userid
|
|
LEFT JOIN {message_users_blocked} mub
|
|
ON mub.userid = :userid2 AND mub.blockeduserid = u.id
|
|
WHERE u.deleted = '0' AND u.confirmed = '1'
|
|
AND (".$DB->sql_like($fullname, ':query', false).")
|
|
$except
|
|
$order", $params);
|
|
} else {
|
|
// Search in courses.
|
|
|
|
// Getting the context IDs or each course.
|
|
$contextids = array();
|
|
foreach ($courseids as $courseid) {
|
|
$context = context_course::instance($courseid);
|
|
$contextids = array_merge($contextids, $context->get_parent_context_ids(true));
|
|
}
|
|
list($contextwhere, $contextparams) = $DB->get_in_or_equal(array_unique($contextids), SQL_PARAMS_NAMED, 'context');
|
|
$params = array_merge($params, $contextparams);
|
|
|
|
// Everyone who has a role assignment in this course or higher.
|
|
// TODO: add enabled enrolment join here (skodak)
|
|
$users = $DB->get_records_sql("SELECT DISTINCT $ufields, mc.id as contactlistid, mub.id as userblockedid
|
|
FROM {user} u
|
|
JOIN {role_assignments} ra ON ra.userid = u.id
|
|
LEFT JOIN {message_contacts} mc
|
|
ON mc.contactid = u.id AND mc.userid = :userid
|
|
LEFT JOIN {message_users_blocked} mub
|
|
ON mub.userid = :userid2 AND mub.blockeduserid = u.id
|
|
WHERE u.deleted = '0' AND u.confirmed = '1'
|
|
AND (".$DB->sql_like($fullname, ':query', false).")
|
|
AND ra.contextid $contextwhere
|
|
$except
|
|
$order", $params);
|
|
|
|
return $users;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Format a message for display in the message history
|
|
*
|
|
* @param object $message the message object
|
|
* @param string $format optional date format
|
|
* @param string $keywords keywords to highlight
|
|
* @param string $class CSS class to apply to the div around the message
|
|
* @return string the formatted message
|
|
*/
|
|
function message_format_message($message, $format='', $keywords='', $class='other') {
|
|
|
|
static $dateformat;
|
|
|
|
//if we haven't previously set the date format or they've supplied a new one
|
|
if ( empty($dateformat) || (!empty($format) && $dateformat != $format) ) {
|
|
if ($format) {
|
|
$dateformat = $format;
|
|
} else {
|
|
$dateformat = get_string('strftimedatetimeshort');
|
|
}
|
|
}
|
|
$time = userdate($message->timecreated, $dateformat);
|
|
|
|
$messagetext = message_format_message_text($message, false);
|
|
|
|
if ($keywords) {
|
|
$messagetext = highlight($keywords, $messagetext);
|
|
}
|
|
|
|
$messagetext .= message_format_contexturl($message);
|
|
|
|
$messagetext = clean_text($messagetext, FORMAT_HTML);
|
|
|
|
return <<<TEMPLATE
|
|
<div class='message $class'>
|
|
<a name="m{$message->id}"></a>
|
|
<span class="message-meta"><span class="time">$time</span></span>: <span class="text">$messagetext</span>
|
|
</div>
|
|
TEMPLATE;
|
|
}
|
|
|
|
/**
|
|
* Format a the context url and context url name of a message for display
|
|
*
|
|
* @param object $message the message object
|
|
* @return string the formatted string
|
|
*/
|
|
function message_format_contexturl($message) {
|
|
$s = null;
|
|
|
|
if (!empty($message->contexturl)) {
|
|
$displaytext = null;
|
|
if (!empty($message->contexturlname)) {
|
|
$displaytext= $message->contexturlname;
|
|
} else {
|
|
$displaytext= $message->contexturl;
|
|
}
|
|
$s .= html_writer::start_tag('div',array('class' => 'messagecontext'));
|
|
$s .= get_string('view').': '.html_writer::tag('a', $displaytext, array('href' => $message->contexturl));
|
|
$s .= html_writer::end_tag('div');
|
|
}
|
|
|
|
return $s;
|
|
}
|
|
|
|
/**
|
|
* Send a message from one user to another. Will be delivered according to the message recipients messaging preferences
|
|
*
|
|
* @param object $userfrom the message sender
|
|
* @param object $userto the message recipient
|
|
* @param string $message the message
|
|
* @param int $format message format such as FORMAT_PLAIN or FORMAT_HTML
|
|
* @return int|false the ID of the new message or false
|
|
*/
|
|
function message_post_message($userfrom, $userto, $message, $format) {
|
|
global $SITE, $CFG, $USER;
|
|
|
|
$eventdata = new \core\message\message();
|
|
$eventdata->courseid = 1;
|
|
$eventdata->component = 'moodle';
|
|
$eventdata->name = 'instantmessage';
|
|
$eventdata->userfrom = $userfrom;
|
|
$eventdata->userto = $userto;
|
|
|
|
//using string manager directly so that strings in the message will be in the message recipients language rather than the senders
|
|
$eventdata->subject = get_string_manager()->get_string('unreadnewmessage', 'message', fullname($userfrom), $userto->lang);
|
|
|
|
if ($format == FORMAT_HTML) {
|
|
$eventdata->fullmessagehtml = $message;
|
|
//some message processors may revert to sending plain text even if html is supplied
|
|
//so we keep both plain and html versions if we're intending to send html
|
|
$eventdata->fullmessage = html_to_text($eventdata->fullmessagehtml);
|
|
} else {
|
|
$eventdata->fullmessage = $message;
|
|
$eventdata->fullmessagehtml = '';
|
|
}
|
|
|
|
$eventdata->fullmessageformat = $format;
|
|
$eventdata->smallmessage = $message;//store the message unfiltered. Clean up on output.
|
|
|
|
$s = new stdClass();
|
|
$s->sitename = format_string($SITE->shortname, true, array('context' => context_course::instance(SITEID)));
|
|
$s->url = $CFG->wwwroot.'/message/index.php?user='.$userto->id.'&id='.$userfrom->id;
|
|
|
|
$emailtagline = get_string_manager()->get_string('emailtagline', 'message', $s, $userto->lang);
|
|
if (!empty($eventdata->fullmessage)) {
|
|
$eventdata->fullmessage .= "\n\n---------------------------------------------------------------------\n".$emailtagline;
|
|
}
|
|
if (!empty($eventdata->fullmessagehtml)) {
|
|
$eventdata->fullmessagehtml .= "<br /><br />---------------------------------------------------------------------<br />".$emailtagline;
|
|
}
|
|
|
|
$eventdata->timecreated = time();
|
|
$eventdata->notification = 0;
|
|
return message_send($eventdata);
|
|
}
|
|
|
|
/**
|
|
* Get all message processors, validate corresponding plugin existance and
|
|
* system configuration
|
|
*
|
|
* @param bool $ready only return ready-to-use processors
|
|
* @param bool $reset Reset list of message processors (used in unit tests)
|
|
* @param bool $resetonly Just reset, then exit
|
|
* @return mixed $processors array of objects containing information on message processors
|
|
*/
|
|
function get_message_processors($ready = false, $reset = false, $resetonly = false) {
|
|
global $DB, $CFG;
|
|
|
|
static $processors;
|
|
if ($reset) {
|
|
$processors = array();
|
|
|
|
if ($resetonly) {
|
|
return $processors;
|
|
}
|
|
}
|
|
|
|
if (empty($processors)) {
|
|
// Get all processors, ensure the name column is the first so it will be the array key
|
|
$processors = $DB->get_records('message_processors', null, 'name DESC', 'name, id, enabled');
|
|
foreach ($processors as &$processor){
|
|
$processor = \core_message\api::get_processed_processor_object($processor);
|
|
}
|
|
}
|
|
if ($ready) {
|
|
// Filter out enabled and system_configured processors
|
|
$readyprocessors = $processors;
|
|
foreach ($readyprocessors as $readyprocessor) {
|
|
if (!($readyprocessor->enabled && $readyprocessor->configured)) {
|
|
unset($readyprocessors[$readyprocessor->name]);
|
|
}
|
|
}
|
|
return $readyprocessors;
|
|
}
|
|
|
|
return $processors;
|
|
}
|
|
|
|
/**
|
|
* Get all message providers, validate their plugin existance and
|
|
* system configuration
|
|
*
|
|
* @return mixed $processors array of objects containing information on message processors
|
|
*/
|
|
function get_message_providers() {
|
|
global $CFG, $DB;
|
|
|
|
$pluginman = core_plugin_manager::instance();
|
|
|
|
$providers = $DB->get_records('message_providers', null, 'name');
|
|
|
|
// Remove all the providers whose plugins are disabled or don't exist
|
|
foreach ($providers as $providerid => $provider) {
|
|
$plugin = $pluginman->get_plugin_info($provider->component);
|
|
if ($plugin) {
|
|
if ($plugin->get_status() === core_plugin_manager::PLUGIN_STATUS_MISSING) {
|
|
unset($providers[$providerid]); // Plugins does not exist
|
|
continue;
|
|
}
|
|
if ($plugin->is_enabled() === false) {
|
|
unset($providers[$providerid]); // Plugin disabled
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
return $providers;
|
|
}
|
|
|
|
/**
|
|
* Get an instance of the message_output class for one of the output plugins.
|
|
* @param string $type the message output type. E.g. 'email' or 'jabber'.
|
|
* @return message_output message_output the requested class.
|
|
*/
|
|
function get_message_processor($type) {
|
|
global $CFG;
|
|
|
|
// Note, we cannot use the get_message_processors function here, becaues this
|
|
// code is called during install after installing each messaging plugin, and
|
|
// get_message_processors caches the list of installed plugins.
|
|
|
|
$processorfile = $CFG->dirroot . "/message/output/{$type}/message_output_{$type}.php";
|
|
if (!is_readable($processorfile)) {
|
|
throw new coding_exception('Unknown message processor type ' . $type);
|
|
}
|
|
|
|
include_once($processorfile);
|
|
|
|
$processclass = 'message_output_' . $type;
|
|
if (!class_exists($processclass)) {
|
|
throw new coding_exception('Message processor ' . $type .
|
|
' does not define the right class');
|
|
}
|
|
|
|
return new $processclass();
|
|
}
|
|
|
|
/**
|
|
* Get messaging outputs default (site) preferences
|
|
*
|
|
* @return object $processors object containing information on message processors
|
|
*/
|
|
function get_message_output_default_preferences() {
|
|
return get_config('message');
|
|
}
|
|
|
|
/**
|
|
* Translate message default settings from binary value to the array of string
|
|
* representing the settings to be stored. Also validate the provided value and
|
|
* use default if it is malformed.
|
|
*
|
|
* @param int $plugindefault Default setting suggested by plugin
|
|
* @param string $processorname The name of processor
|
|
* @return array $settings array of strings in the order: $permitted, $loggedin, $loggedoff.
|
|
*/
|
|
function translate_message_default_setting($plugindefault, $processorname) {
|
|
// Preset translation arrays
|
|
$permittedvalues = array(
|
|
0x04 => 'disallowed',
|
|
0x08 => 'permitted',
|
|
0x0c => 'forced',
|
|
);
|
|
|
|
$loggedinstatusvalues = array(
|
|
0x00 => null, // use null if loggedin/loggedoff is not defined
|
|
0x01 => 'loggedin',
|
|
0x02 => 'loggedoff',
|
|
);
|
|
|
|
// define the default setting
|
|
$processor = get_message_processor($processorname);
|
|
$default = $processor->get_default_messaging_settings();
|
|
|
|
// Validate the value. It should not exceed the maximum size
|
|
if (!is_int($plugindefault) || ($plugindefault > 0x0f)) {
|
|
debugging(get_string('errortranslatingdefault', 'message'));
|
|
$plugindefault = $default;
|
|
}
|
|
// Use plugin default setting of 'permitted' is 0
|
|
if (!($plugindefault & MESSAGE_PERMITTED_MASK)) {
|
|
$plugindefault = $default;
|
|
}
|
|
|
|
$permitted = $permittedvalues[$plugindefault & MESSAGE_PERMITTED_MASK];
|
|
$loggedin = $loggedoff = null;
|
|
|
|
if (($plugindefault & MESSAGE_PERMITTED_MASK) == MESSAGE_PERMITTED) {
|
|
$loggedin = $loggedinstatusvalues[$plugindefault & MESSAGE_DEFAULT_LOGGEDIN];
|
|
$loggedoff = $loggedinstatusvalues[$plugindefault & MESSAGE_DEFAULT_LOGGEDOFF];
|
|
}
|
|
|
|
return array($permitted, $loggedin, $loggedoff);
|
|
}
|
|
|
|
/**
|
|
* Get messages sent or/and received by the specified users.
|
|
* Please note that this function return deleted messages too.
|
|
*
|
|
* @param int $useridto the user id who received the message
|
|
* @param int $useridfrom the user id who sent the message. -10 or -20 for no-reply or support user
|
|
* @param int $notifications 1 for retrieving notifications, 0 for messages, -1 for both
|
|
* @param bool $read true for retrieving read messages, false for unread
|
|
* @param string $sort the column name to order by including optionally direction
|
|
* @param int $limitfrom limit from
|
|
* @param int $limitnum limit num
|
|
* @return external_description
|
|
* @since 2.8
|
|
*/
|
|
function message_get_messages($useridto, $useridfrom = 0, $notifications = -1, $read = true,
|
|
$sort = 'mr.timecreated DESC', $limitfrom = 0, $limitnum = 0) {
|
|
global $DB;
|
|
|
|
// If the 'useridto' value is empty then we are going to retrieve messages sent by the useridfrom to any user.
|
|
if (empty($useridto)) {
|
|
$userfields = get_all_user_name_fields(true, 'u', '', 'userto');
|
|
$messageuseridtosql = 'u.id as useridto';
|
|
} else {
|
|
$userfields = get_all_user_name_fields(true, 'u', '', 'userfrom');
|
|
$messageuseridtosql = "$useridto as useridto";
|
|
}
|
|
|
|
// Create the SQL we will be using.
|
|
$messagesql = "SELECT mr.*, $userfields, 0 as notification, '' as contexturl, '' as contexturlname,
|
|
mua.timecreated as timeusertodeleted, mua2.timecreated as timeread,
|
|
mua3.timecreated as timeuserfromdeleted, $messageuseridtosql
|
|
FROM {messages} mr
|
|
INNER JOIN {message_conversations} mc
|
|
ON mc.id = mr.conversationid
|
|
INNER JOIN {message_conversation_members} mcm
|
|
ON mcm.conversationid = mc.id ";
|
|
|
|
$notificationsql = "SELECT mr.*, $userfields, 1 as notification
|
|
FROM {notifications} mr ";
|
|
|
|
$messagejoinsql = "LEFT JOIN {message_user_actions} mua
|
|
ON (mua.messageid = mr.id AND mua.userid = mcm.userid AND mua.action = ?)
|
|
LEFT JOIN {message_user_actions} mua2
|
|
ON (mua2.messageid = mr.id AND mua2.userid = mcm.userid AND mua2.action = ?)
|
|
LEFT JOIN {message_user_actions} mua3
|
|
ON (mua3.messageid = mr.id AND mua3.userid = mr.useridfrom AND mua3.action = ?)";
|
|
$messagejoinparams = [\core_message\api::MESSAGE_ACTION_DELETED, \core_message\api::MESSAGE_ACTION_READ,
|
|
\core_message\api::MESSAGE_ACTION_DELETED];
|
|
$notificationsparams = [];
|
|
|
|
// If the 'useridto' value is empty then we are going to retrieve messages sent by the useridfrom to any user.
|
|
if (empty($useridto)) {
|
|
// Create the messaging query and params.
|
|
$messagesql .= "INNER JOIN {user} u
|
|
ON u.id = mcm.userid
|
|
$messagejoinsql
|
|
WHERE mr.useridfrom = ?
|
|
AND mr.useridfrom != mcm.userid
|
|
AND u.deleted = 0 ";
|
|
$messageparams = array_merge($messagejoinparams, [$useridfrom]);
|
|
|
|
// Create the notifications query and params.
|
|
$notificationsql .= "INNER JOIN {user} u
|
|
ON u.id = mr.useridto
|
|
WHERE mr.useridfrom = ?
|
|
AND u.deleted = 0 ";
|
|
$notificationsparams[] = $useridfrom;
|
|
} else {
|
|
// Create the messaging query and params.
|
|
// Left join because useridfrom may be -10 or -20 (no-reply and support users).
|
|
$messagesql .= "LEFT JOIN {user} u
|
|
ON u.id = mr.useridfrom
|
|
$messagejoinsql
|
|
WHERE mcm.userid = ?
|
|
AND mr.useridfrom != mcm.userid
|
|
AND u.deleted = 0 ";
|
|
$messageparams = array_merge($messagejoinparams, [$useridto]);
|
|
if (!empty($useridfrom)) {
|
|
$messagesql .= " AND mr.useridfrom = ? ";
|
|
$messageparams[] = $useridfrom;
|
|
}
|
|
|
|
// Create the notifications query and params.
|
|
// Left join because useridfrom may be -10 or -20 (no-reply and support users).
|
|
$notificationsql .= "LEFT JOIN {user} u
|
|
ON (u.id = mr.useridfrom AND u.deleted = 0)
|
|
WHERE mr.useridto = ? ";
|
|
$notificationsparams[] = $useridto;
|
|
if (!empty($useridfrom)) {
|
|
$notificationsql .= " AND mr.useridfrom = ? ";
|
|
$notificationsparams[] = $useridfrom;
|
|
}
|
|
}
|
|
if ($read) {
|
|
$notificationsql .= "AND mr.timeread IS NOT NULL ";
|
|
} else {
|
|
$notificationsql .= "AND mr.timeread IS NULL ";
|
|
}
|
|
$messagesql .= "ORDER BY $sort";
|
|
$notificationsql .= "ORDER BY $sort";
|
|
|
|
// Handle messages if needed.
|
|
if ($notifications === -1 || $notifications === 0) {
|
|
$messages = $DB->get_records_sql($messagesql, $messageparams, $limitfrom, $limitnum);
|
|
// Get rid of the messages that have either been read or not read depending on the value of $read.
|
|
$messages = array_filter($messages, function ($message) use ($read) {
|
|
if ($read) {
|
|
return !is_null($message->timeread);
|
|
}
|
|
|
|
return is_null($message->timeread);
|
|
});
|
|
}
|
|
|
|
// All.
|
|
if ($notifications === -1) {
|
|
return array_merge($messages, $DB->get_records_sql($notificationsql, $notificationsparams, $limitfrom, $limitnum));
|
|
} else if ($notifications === 1) { // Just notifications.
|
|
return $DB->get_records_sql($notificationsql, $notificationsparams, $limitfrom, $limitnum);
|
|
}
|
|
|
|
// Just messages.
|
|
return $messages;
|
|
}
|
|
|
|
/**
|
|
* Handles displaying processor settings in a fragment.
|
|
*
|
|
* @param array $args
|
|
* @return bool|string
|
|
* @throws moodle_exception
|
|
*/
|
|
function message_output_fragment_processor_settings($args = []) {
|
|
global $PAGE;
|
|
|
|
if (!isset($args['type'])) {
|
|
throw new moodle_exception('Must provide a processor type');
|
|
}
|
|
|
|
if (!isset($args['userid'])) {
|
|
throw new moodle_exception('Must provide a userid');
|
|
}
|
|
|
|
$type = $args['type'];
|
|
$userid = $args['userid'];
|
|
|
|
$user = core_user::get_user($userid, '*', MUST_EXIST);
|
|
$processor = get_message_processor($type);
|
|
$providers = message_get_providers_for_user($userid);
|
|
$processorwrapper = new stdClass();
|
|
$processorwrapper->object = $processor;
|
|
$preferences = \core_message\api::get_all_message_preferences([$processorwrapper], $providers, $user);
|
|
|
|
$processoroutput = new \core_message\output\preferences\processor($processor, $preferences, $user, $type);
|
|
$renderer = $PAGE->get_renderer('core', 'message');
|
|
|
|
return $renderer->render_from_template('core_message/preferences_processor', $processoroutput->export_for_template($renderer));
|
|
}
|
|
|
|
/**
|
|
* Checks if current user is allowed to edit messaging preferences of another user
|
|
*
|
|
* @param stdClass $user user whose preferences we are updating
|
|
* @return bool
|
|
*/
|
|
function core_message_can_edit_message_profile($user) {
|
|
global $USER;
|
|
if ($user->id == $USER->id) {
|
|
return has_capability('moodle/user:editownmessageprofile', context_system::instance());
|
|
} else {
|
|
$personalcontext = context_user::instance($user->id);
|
|
if (!has_capability('moodle/user:editmessageprofile', $personalcontext)) {
|
|
return false;
|
|
}
|
|
if (isguestuser($user)) {
|
|
return false;
|
|
}
|
|
// No editing of admins by non-admins.
|
|
if (is_siteadmin($user) and !is_siteadmin($USER)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implements callback user_preferences, whitelists preferences that users are allowed to update directly
|
|
*
|
|
* Used in {@see core_user::fill_preferences_cache()}, see also {@see useredit_update_user_preference()}
|
|
*
|
|
* @return array
|
|
*/
|
|
function core_message_user_preferences() {
|
|
$preferences = [];
|
|
$preferences['message_blocknoncontacts'] = array(
|
|
'type' => PARAM_INT,
|
|
'null' => NULL_NOT_ALLOWED,
|
|
'default' => 0,
|
|
'choices' => array(
|
|
\core_message\api::MESSAGE_PRIVACY_ONLYCONTACTS,
|
|
\core_message\api::MESSAGE_PRIVACY_COURSEMEMBER,
|
|
\core_message\api::MESSAGE_PRIVACY_SITE
|
|
),
|
|
'cleancallback' => function ($value) {
|
|
global $CFG;
|
|
|
|
// When site-wide messaging between users is disabled, MESSAGE_PRIVACY_SITE should be converted.
|
|
if (empty($CFG->messagingallusers) && $value === \core_message\api::MESSAGE_PRIVACY_SITE) {
|
|
return \core_message\api::MESSAGE_PRIVACY_COURSEMEMBER;
|
|
}
|
|
return $value;
|
|
}
|
|
);
|
|
$preferences['message_entertosend'] = array(
|
|
'type' => PARAM_BOOL,
|
|
'null' => NULL_NOT_ALLOWED,
|
|
'default' => false
|
|
);
|
|
$preferences['/^message_provider_([\w\d_]*)_logged(in|off)$/'] = array('isregex' => true, 'type' => PARAM_NOTAGS,
|
|
'null' => NULL_NOT_ALLOWED, 'default' => 'none',
|
|
'permissioncallback' => function ($user, $preferencename) {
|
|
global $CFG;
|
|
require_once($CFG->libdir.'/messagelib.php');
|
|
if (core_message_can_edit_message_profile($user) &&
|
|
preg_match('/^message_provider_([\w\d_]*)_logged(in|off)$/', $preferencename, $matches)) {
|
|
$providers = message_get_providers_for_user($user->id);
|
|
foreach ($providers as $provider) {
|
|
if ($matches[1] === $provider->component . '_' . $provider->name) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
'cleancallback' => function ($value, $preferencename) {
|
|
if ($value === 'none' || empty($value)) {
|
|
return 'none';
|
|
}
|
|
$parts = explode('/,/', $value);
|
|
$processors = array_keys(get_message_processors());
|
|
array_filter($parts, function($v) use ($processors) {return in_array($v, $processors);});
|
|
return $parts ? join(',', $parts) : 'none';
|
|
});
|
|
return $preferences;
|
|
}
|
|
|
|
/**
|
|
* Renders the popup.
|
|
*
|
|
* @param renderer_base $renderer
|
|
* @return string The HTML
|
|
*/
|
|
function core_message_render_navbar_output(\renderer_base $renderer) {
|
|
global $USER, $CFG;
|
|
|
|
// Early bail out conditions.
|
|
if (!isloggedin() || isguestuser() || user_not_fully_set_up($USER) ||
|
|
get_user_preferences('auth_forcepasswordchange') ||
|
|
(!$USER->policyagreed && !is_siteadmin() &&
|
|
($manager = new \core_privacy\local\sitepolicy\manager()) && $manager->is_defined())) {
|
|
return '';
|
|
}
|
|
|
|
$output = '';
|
|
|
|
// Add the messages popover.
|
|
if (!empty($CFG->messaging)) {
|
|
$unreadcount = \core_message\api::count_unread_conversations($USER);
|
|
$requestcount = \core_message\api::count_received_contact_requests($USER);
|
|
$context = [
|
|
'userid' => $USER->id,
|
|
'unreadcount' => $unreadcount + $requestcount
|
|
];
|
|
$output .= $renderer->render_from_template('core_message/message_popover', $context);
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Render the message drawer to be included in the top of the body of
|
|
* each page.
|
|
*
|
|
* @return string HTML
|
|
*/
|
|
function core_message_standard_after_main_region_html() {
|
|
global $USER, $CFG, $PAGE;
|
|
|
|
// Early bail out conditions.
|
|
if (empty($CFG->messaging) || !isloggedin() || isguestuser() || user_not_fully_set_up($USER) ||
|
|
get_user_preferences('auth_forcepasswordchange') ||
|
|
(!$USER->policyagreed && !is_siteadmin() &&
|
|
($manager = new \core_privacy\local\sitepolicy\manager()) && $manager->is_defined())) {
|
|
return '';
|
|
}
|
|
|
|
$renderer = $PAGE->get_renderer('core');
|
|
$individualconversationcount = \core_message\api::count_conversations(
|
|
$USER,
|
|
\core_message\api::MESSAGE_CONVERSATION_TYPE_INDIVIDUAL,
|
|
true
|
|
);
|
|
$groupconversationcount = \core_message\api::count_conversations(
|
|
$USER,
|
|
\core_message\api::MESSAGE_CONVERSATION_TYPE_GROUP,
|
|
true
|
|
);
|
|
$systemcontext = \context_system::instance();
|
|
$usercontext = \context_user::instance($USER->id);
|
|
$ufservice = \core_favourites\service_factory::get_service_for_user_context($usercontext);
|
|
$favouriteconversationcount = $ufservice->count_favourites_by_type('core_message', 'message_conversations', $systemcontext);
|
|
$requestcount = \core_message\api::count_received_contact_requests($USER);
|
|
$contactscount = \core_message\api::count_contacts($USER->id);
|
|
|
|
// Get the privacy settings options for being messaged.
|
|
$privacysetting = \core_message\api::get_user_privacy_messaging_preference($USER->id);
|
|
$choices = [];
|
|
$choices[] = [
|
|
'value' => \core_message\api::MESSAGE_PRIVACY_ONLYCONTACTS,
|
|
'text' => get_string('contactableprivacy_onlycontacts', 'message'),
|
|
'checked' => ($privacysetting == \core_message\api::MESSAGE_PRIVACY_ONLYCONTACTS)
|
|
];
|
|
$choices[] = [
|
|
'value' => \core_message\api::MESSAGE_PRIVACY_COURSEMEMBER,
|
|
'text' => get_string('contactableprivacy_coursemember', 'message'),
|
|
'checked' => ($privacysetting == \core_message\api::MESSAGE_PRIVACY_COURSEMEMBER)
|
|
];
|
|
if (!empty($CFG->messagingallusers)) {
|
|
// Add the MESSAGE_PRIVACY_SITE option when site-wide messaging between users is enabled.
|
|
$choices[] = [
|
|
'value' => \core_message\api::MESSAGE_PRIVACY_SITE,
|
|
'text' => get_string('contactableprivacy_site', 'message'),
|
|
'checked' => ($privacysetting == \core_message\api::MESSAGE_PRIVACY_SITE)
|
|
];
|
|
}
|
|
// Email settings.
|
|
$emailloggedin = get_user_preferences('message_provider_moodle_instantmessage_loggedin', 'none', $USER->id);
|
|
$emailloggedoff = get_user_preferences('message_provider_moodle_instantmessage_loggedoff', 'none', $USER->id);
|
|
$emailenabled = $emailloggedin == 'email' && $emailloggedoff == 'email';
|
|
|
|
// Enter to send.
|
|
$entertosend = get_user_preferences('message_entertosend', false, $USER->id);
|
|
|
|
return $renderer->render_from_template('core_message/message_drawer', [
|
|
'contactrequestcount' => $requestcount,
|
|
'loggedinuser' => [
|
|
'id' => $USER->id,
|
|
'midnight' => usergetmidnight(time())
|
|
],
|
|
'overview' => [
|
|
'messages' => [
|
|
'expanded' => empty($favouriteconversationcount) && empty($groupconversationcount),
|
|
'count' => [
|
|
'unread' => 0, // TODO: fix me.
|
|
'total' => $individualconversationcount
|
|
],
|
|
'placeholders' => array_fill(0, $individualconversationcount, true)
|
|
],
|
|
'groupmessages' => [
|
|
'expanded' => empty($favouriteconversationcount) && !empty($groupconversationcount),
|
|
'count' => [
|
|
'unread' => 0, // TODO: fix me.
|
|
'total' => $groupconversationcount
|
|
],
|
|
'placeholders' => array_fill(0, $groupconversationcount, true)
|
|
],
|
|
'favourites' => [
|
|
'expanded' => !empty($favouriteconversationcount),
|
|
'count' => [
|
|
'unread' => 0, // TODO: fix me.
|
|
'total' => $favouriteconversationcount
|
|
],
|
|
'placeholders' => array_fill(0, $favouriteconversationcount, true)
|
|
],
|
|
],
|
|
'contacts' => [
|
|
'sectioncontacts' => [
|
|
'placeholders' => array_fill(0, $contactscount > 50 ? 50 : $contactscount, true)
|
|
],
|
|
'sectionrequests' => [
|
|
'placeholders' => array_fill(0, $requestcount > 50 ? 50 : $requestcount, true)
|
|
],
|
|
],
|
|
'settings' => [
|
|
'privacy' => $choices,
|
|
'emailenabled' => $emailenabled,
|
|
'entertosend' => $entertosend
|
|
]
|
|
]);
|
|
}
|