MDL-65896 admin: add admin setting to show emoji picker
[moodle.git] / message / classes / helper.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Contains helper class for the message area.
19  *
20  * @package    core_message
21  * @copyright  2016 Mark Nelson <markn@moodle.com>
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 namespace core_message;
27 defined('MOODLE_INTERNAL') || die();
29 require_once($CFG->dirroot . '/message/lib.php');
31 /**
32  * Helper class for the message area.
33  *
34  * @copyright  2016 Mark Nelson <markn@moodle.com>
35  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
36  */
37 class helper {
39     /**
40      * Helper function to retrieve the messages between two users
41      *
42      * TODO: This function should be removed once the related web services go through final deprecation.
43      * The related web services are data_for_messagearea_messages AND data_for_messagearea_get_most_recent_message.
44      * Followup: MDL-63261
45      *
46      * @param int $userid the current user
47      * @param int $otheruserid the other user
48      * @param int $timedeleted the time the message was deleted
49      * @param int $limitfrom
50      * @param int $limitnum
51      * @param string $sort
52      * @param int $timefrom the time from the message being sent
53      * @param int $timeto the time up until the message being sent
54      * @return array of messages
55      */
56     public static function get_messages($userid, $otheruserid, $timedeleted = 0, $limitfrom = 0, $limitnum = 0,
57                                         $sort = 'timecreated ASC', $timefrom = 0, $timeto = 0) {
58         global $DB;
60         $hash = self::get_conversation_hash([$userid, $otheruserid]);
62         $sql = "SELECT m.id, m.useridfrom, m.subject, m.fullmessage, m.fullmessagehtml,
63                        m.fullmessageformat, m.fullmessagetrust, m.smallmessage, m.timecreated,
64                        mc.contextid, muaread.timecreated AS timeread
65                   FROM {message_conversations} mc
66             INNER JOIN {messages} m
67                     ON m.conversationid = mc.id
68              LEFT JOIN {message_user_actions} muaread
69                     ON (muaread.messageid = m.id
70                    AND muaread.userid = :userid1
71                    AND muaread.action = :readaction)";
72         $params = ['userid1' => $userid, 'readaction' => api::MESSAGE_ACTION_READ, 'convhash' => $hash];
74         if (empty($timedeleted)) {
75             $sql .= " LEFT JOIN {message_user_actions} mua
76                              ON (mua.messageid = m.id
77                             AND mua.userid = :userid2
78                             AND mua.action = :deleteaction
79                             AND mua.timecreated is NOT NULL)";
80         } else {
81             $sql .= " INNER JOIN {message_user_actions} mua
82                               ON (mua.messageid = m.id
83                              AND mua.userid = :userid2
84                              AND mua.action = :deleteaction
85                              AND mua.timecreated = :timedeleted)";
86             $params['timedeleted'] = $timedeleted;
87         }
89         $params['userid2'] = $userid;
90         $params['deleteaction'] = api::MESSAGE_ACTION_DELETED;
92         $sql .= " WHERE mc.convhash = :convhash";
94         if (!empty($timefrom)) {
95             $sql .= " AND m.timecreated >= :timefrom";
96             $params['timefrom'] = $timefrom;
97         }
99         if (!empty($timeto)) {
100             $sql .= " AND m.timecreated <= :timeto";
101             $params['timeto'] = $timeto;
102         }
104         if (empty($timedeleted)) {
105             $sql .= " AND mua.id is NULL";
106         }
108         $sql .= " ORDER BY m.$sort";
110         $messages = $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
111         foreach ($messages as &$message) {
112             $message->useridto = ($message->useridfrom == $userid) ? $otheruserid : $userid;
113         }
115         return $messages;
116     }
118     /**
119      * Helper function to retrieve conversation messages.
120      *
121      * @param  int $userid The current user.
122      * @param  int $convid The conversation identifier.
123      * @param  int $timedeleted The time the message was deleted
124      * @param  int $limitfrom Return a subset of records, starting at this point (optional).
125      * @param  int $limitnum Return a subset comprising this many records in total (optional, required if $limitfrom is set).
126      * @param  string $sort The column name to order by including optionally direction.
127      * @param  int $timefrom The time from the message being sent.
128      * @param  int $timeto The time up until the message being sent.
129      * @return array of messages
130      */
131     public static function get_conversation_messages(int $userid, int $convid, int $timedeleted = 0, int $limitfrom = 0,
132                                                      int $limitnum = 0, string $sort = 'timecreated ASC', int $timefrom = 0,
133                                                      int $timeto = 0) : array {
134         global $DB;
136         $sql = "SELECT m.id, m.useridfrom, m.subject, m.fullmessage, m.fullmessagehtml,
137                        m.fullmessageformat, m.fullmessagetrust, m.smallmessage, m.timecreated,
138                        mc.contextid, muaread.timecreated AS timeread
139                   FROM {message_conversations} mc
140             INNER JOIN {messages} m
141                     ON m.conversationid = mc.id
142              LEFT JOIN {message_user_actions} muaread
143                     ON (muaread.messageid = m.id
144                    AND muaread.userid = :userid1
145                    AND muaread.action = :readaction)";
146         $params = ['userid1' => $userid, 'readaction' => api::MESSAGE_ACTION_READ, 'convid' => $convid];
148         if (empty($timedeleted)) {
149             $sql .= " LEFT JOIN {message_user_actions} mua
150                              ON (mua.messageid = m.id
151                             AND mua.userid = :userid2
152                             AND mua.action = :deleteaction
153                             AND mua.timecreated is NOT NULL)";
154         } else {
155             $sql .= " INNER JOIN {message_user_actions} mua
156                               ON (mua.messageid = m.id
157                              AND mua.userid = :userid2
158                              AND mua.action = :deleteaction
159                              AND mua.timecreated = :timedeleted)";
160             $params['timedeleted'] = $timedeleted;
161         }
163         $params['userid2'] = $userid;
164         $params['deleteaction'] = api::MESSAGE_ACTION_DELETED;
166         $sql .= " WHERE mc.id = :convid";
168         if (!empty($timefrom)) {
169             $sql .= " AND m.timecreated >= :timefrom";
170             $params['timefrom'] = $timefrom;
171         }
173         if (!empty($timeto)) {
174             $sql .= " AND m.timecreated <= :timeto";
175             $params['timeto'] = $timeto;
176         }
178         if (empty($timedeleted)) {
179             $sql .= " AND mua.id is NULL";
180         }
182         $sql .= " ORDER BY m.$sort";
184         $messages = $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
186         return $messages;
187     }
189     /**
190      * Helper function to return a conversation messages with the involved members (only the ones
191      * who have sent any of these messages).
192      *
193      * @param int $userid The current userid.
194      * @param int $convid The conversation id.
195      * @param array $messages The formated array messages.
196      * @return array A conversation array with the messages and the involved members.
197      */
198     public static function format_conversation_messages(int $userid, int $convid, array $messages) : array {
199         global $USER;
201         // Create the conversation array.
202         $conversation = array(
203             'id' => $convid,
204         );
206         // Store the messages.
207         $arrmessages = array();
209         foreach ($messages as $message) {
210             // Store the message information.
211             $msg = new \stdClass();
212             $msg->id = $message->id;
213             $msg->useridfrom = $message->useridfrom;
214             $msg->text = message_format_message_text($message);
215             $msg->timecreated = $message->timecreated;
216             $arrmessages[] = $msg;
217         }
218         // Add the messages to the conversation.
219         $conversation['messages'] = $arrmessages;
221         // Get the users who have sent any of the $messages.
222         $memberids = array_unique(array_map(function($message) {
223             return $message->useridfrom;
224         }, $messages));
226         if (!empty($memberids)) {
227             // Get members information.
228             $conversation['members'] = self::get_member_info($userid, $memberids);
229         } else {
230             $conversation['members'] = array();
231         }
233         return $conversation;
234     }
236     /**
237      * Helper function to return an array of messages.
238      *
239      * TODO: This function should be removed once the related web services go through final deprecation.
240      * The related web services are data_for_messagearea_messages AND data_for_messagearea_get_most_recent_message.
241      * Followup: MDL-63261
242      *
243      * @param int $userid
244      * @param array $messages
245      * @return array
246      */
247     public static function create_messages($userid, $messages) {
248         // Store the messages.
249         $arrmessages = array();
251         // We always view messages from oldest to newest, ensure we have it in that order.
252         $lastmessage = end($messages);
253         $firstmessage = reset($messages);
254         if ($lastmessage->timecreated < $firstmessage->timecreated) {
255             $messages = array_reverse($messages);
256         }
258         // Keeps track of the last day, month and year combo we were viewing.
259         $day = '';
260         $month = '';
261         $year = '';
262         foreach ($messages as $message) {
263             // Check if we are now viewing a different block period.
264             $displayblocktime = false;
265             $date = usergetdate($message->timecreated);
266             if ($day != $date['mday'] || $month != $date['month'] || $year != $date['year']) {
267                 $day = $date['mday'];
268                 $month = $date['month'];
269                 $year = $date['year'];
270                 $displayblocktime = true;
271             }
272             // Store the message to pass to the renderable.
273             $msg = new \stdClass();
274             $msg->id = $message->id;
275             $msg->text = message_format_message_text($message);
276             $msg->currentuserid = $userid;
277             $msg->useridfrom = $message->useridfrom;
278             $msg->useridto = $message->useridto;
279             $msg->displayblocktime = $displayblocktime;
280             $msg->timecreated = $message->timecreated;
281             $msg->timeread = $message->timeread;
282             $arrmessages[] = $msg;
283         }
285         return $arrmessages;
286     }
288     /**
289      * Helper function for creating a contact object.
290      *
291      * @param \stdClass $contact
292      * @param string $prefix
293      * @return \stdClass
294      */
295     public static function create_contact($contact, $prefix = '') {
296         global $PAGE;
298         // Create the data we are going to pass to the renderable.
299         $userfields = \user_picture::unalias($contact, array('lastaccess'), $prefix . 'id', $prefix);
300         $data = new \stdClass();
301         $data->userid = $userfields->id;
302         $data->useridfrom = null;
303         $data->fullname = fullname($userfields);
304         // Get the user picture data.
305         $userpicture = new \user_picture($userfields);
306         $userpicture->size = 1; // Size f1.
307         $data->profileimageurl = $userpicture->get_url($PAGE)->out(false);
308         $userpicture->size = 0; // Size f2.
309         $data->profileimageurlsmall = $userpicture->get_url($PAGE)->out(false);
310         // Store the message if we have it.
311         $data->ismessaging = false;
312         $data->lastmessage = null;
313         $data->lastmessagedate = null;
314         $data->messageid = null;
315         if (isset($contact->smallmessage)) {
316             $data->ismessaging = true;
317             // Strip the HTML tags from the message for displaying in the contact area.
318             $data->lastmessage = clean_param($contact->smallmessage, PARAM_NOTAGS);
319             $data->lastmessagedate = $contact->timecreated;
320             $data->useridfrom = $contact->useridfrom;
321             if (isset($contact->messageid)) {
322                 $data->messageid = $contact->messageid;
323             }
324         }
325         $data->isonline = null;
326         $user = \core_user::get_user($data->userid);
327         if (self::show_online_status($user)) {
328             $data->isonline = self::is_online($userfields->lastaccess);
329         }
330         $data->isblocked = isset($contact->blocked) ? (bool) $contact->blocked : false;
331         $data->isread = isset($contact->isread) ? (bool) $contact->isread : false;
332         $data->unreadcount = isset($contact->unreadcount) ? $contact->unreadcount : null;
333         $data->conversationid = $contact->conversationid ?? null;
335         return $data;
336     }
338     /**
339      * Helper function for checking if we should show the user's online status.
340      *
341      * @param \stdClass $user
342      * @return boolean
343      */
344     public static function show_online_status($user) {
345         global $CFG;
347         require_once($CFG->dirroot . '/user/lib.php');
349         if ($lastaccess = user_get_user_details($user, null, array('lastaccess'))) {
350             if (isset($lastaccess['lastaccess'])) {
351                 return true;
352             }
353         }
355         return false;
356     }
358     /**
359      * Helper function for checking the time meets the 'online' condition.
360      *
361      * @param int $lastaccess
362      * @return boolean
363      */
364     public static function is_online($lastaccess) {
365         global $CFG;
367         // Variable to check if we consider this user online or not.
368         $timetoshowusers = 300; // Seconds default.
369         if (isset($CFG->block_online_users_timetosee)) {
370             $timetoshowusers = $CFG->block_online_users_timetosee * 60;
371         }
372         $time = time() - $timetoshowusers;
374         return $lastaccess >= $time;
375     }
377     /**
378      * Get providers preferences.
379      *
380      * @param array $providers
381      * @param int $userid
382      * @return \stdClass
383      */
384     public static function get_providers_preferences($providers, $userid) {
385         $preferences = new \stdClass();
387         // Get providers preferences.
388         foreach ($providers as $provider) {
389             foreach (array('loggedin', 'loggedoff') as $state) {
390                 $linepref = get_user_preferences('message_provider_' . $provider->component . '_' . $provider->name
391                     . '_' . $state, '', $userid);
392                 if ($linepref == '') {
393                     continue;
394                 }
395                 $lineprefarray = explode(',', $linepref);
396                 $preferences->{$provider->component.'_'.$provider->name.'_'.$state} = array();
397                 foreach ($lineprefarray as $pref) {
398                     $preferences->{$provider->component.'_'.$provider->name.'_'.$state}[$pref] = 1;
399                 }
400             }
401         }
403         return $preferences;
404     }
406     /**
407      * Requires the JS libraries for the toggle contact button.
408      *
409      * @return void
410      */
411     public static function togglecontact_requirejs() {
412         global $PAGE;
414         static $done = false;
415         if ($done) {
416             return;
417         }
419         $PAGE->requires->js_call_amd('core_message/toggle_contact_button', 'enhance', array('#toggle-contact-button'));
420         $done = true;
421     }
423     /**
424      * Returns the attributes to place on a contact button.
425      *
426      * @param object $user User object.
427      * @param bool $iscontact
428      * @return array
429      */
430     public static function togglecontact_link_params($user, $iscontact = false) {
431         $params = array(
432             'data-userid' => $user->id,
433             'data-is-contact' => $iscontact,
434             'id' => 'toggle-contact-button',
435             'role' => 'button',
436             'class' => 'ajax-contact-button',
437         );
439         return $params;
440     }
442     /**
443      * Requires the JS libraries for the message user button.
444      *
445      * @return void
446      */
447     public static function messageuser_requirejs() {
448         global $PAGE;
450         static $done = false;
451         if ($done) {
452             return;
453         }
455         $PAGE->requires->js_call_amd('core_message/message_user_button', 'send', array('#message-user-button'));
456         $done = true;
457     }
459     /**
460      * Returns the attributes to place on the message user button.
461      *
462      * @param int $useridto
463      * @return array
464      */
465     public static function messageuser_link_params(int $useridto) : array {
466         global $USER;
468         return [
469             'id' => 'message-user-button',
470             'role' => 'button',
471             'data-conversationid' => api::get_conversation_between_users([$USER->id, $useridto]),
472             'data-userid' => $useridto,
473         ];
474     }
476     /**
477      * Returns the conversation hash between users for easy look-ups in the DB.
478      *
479      * @param array $userids
480      * @return string
481      */
482     public static function get_conversation_hash(array $userids) {
483         sort($userids);
485         return sha1(implode('-', $userids));
486     }
488     /**
489      * Returns the cache key for the time created value of the last message of this conversation.
490      *
491      * @param int $convid The conversation identifier.
492      * @return string The key.
493      */
494     public static function get_last_message_time_created_cache_key(int $convid) {
495         return $convid;
496     }
498     /**
499      * Checks if legacy messages exist for a given user.
500      *
501      * @param int $userid
502      * @return bool
503      */
504     public static function legacy_messages_exist($userid) {
505         global $DB;
507         $sql = "SELECT id
508                   FROM {message} m
509                  WHERE useridfrom = ?
510                     OR useridto = ?";
511         $messageexists = $DB->record_exists_sql($sql, [$userid, $userid]);
513         $sql = "SELECT id
514                   FROM {message_read} m
515                  WHERE useridfrom = ?
516                     OR useridto = ?";
517         $messagereadexists = $DB->record_exists_sql($sql, [$userid, $userid]);
519         return $messageexists || $messagereadexists;
520     }
522     /**
523      * Returns conversation member info for the supplied users, relative to the supplied referenceuserid.
524      *
525      * This is the basic structure used when returning members, and includes information about the relationship between each member
526      * and the referenceuser, such as a whether the referenceuser has marked the member as a contact, or has blocked them.
527      *
528      * @param int $referenceuserid the id of the user which check contact and blocked status.
529      * @param array $userids
530      * @param bool $includecontactrequests Do we want to include contact requests with this data?
531      * @param bool $includeprivacyinfo Do we want to include whether the user can message another, and if the user
532      *             requires a contact.
533      * @return array the array of objects containing member info, indexed by userid.
534      * @throws \coding_exception
535      * @throws \dml_exception
536      */
537     public static function get_member_info(int $referenceuserid, array $userids, bool $includecontactrequests = false,
538                                            bool $includeprivacyinfo = false) : array {
539         global $DB, $PAGE;
541         // Prevent exception being thrown when array is empty.
542         if (empty($userids)) {
543             return [];
544         }
546         list($useridsql, $usersparams) = $DB->get_in_or_equal($userids);
547         $userfields = \user_picture::fields('u', array('lastaccess'));
548         $userssql = "SELECT $userfields, u.deleted, mc.id AS contactid, mub.id AS blockedid
549                        FROM {user} u
550                   LEFT JOIN {message_contacts} mc
551                          ON ((mc.userid = ? AND mc.contactid = u.id) OR (mc.userid = u.id AND mc.contactid = ?))
552                   LEFT JOIN {message_users_blocked} mub
553                          ON (mub.userid = ? AND mub.blockeduserid = u.id)
554                       WHERE u.id $useridsql";
555         $usersparams = array_merge([$referenceuserid, $referenceuserid, $referenceuserid], $usersparams);
556         $otherusers = $DB->get_records_sql($userssql, $usersparams);
558         $members = [];
559         foreach ($otherusers as $member) {
560             // Set basic data.
561             $data = new \stdClass();
562             $data->id = $member->id;
563             $data->fullname = fullname($member);
565             // Create the URL for their profile.
566             $profileurl = new \moodle_url('/user/profile.php', ['id' => $member->id]);
567             $data->profileurl = $profileurl->out(false);
569             // Set the user picture data.
570             $userpicture = new \user_picture($member);
571             $userpicture->size = 1; // Size f1.
572             $data->profileimageurl = $userpicture->get_url($PAGE)->out(false);
573             $userpicture->size = 0; // Size f2.
574             $data->profileimageurlsmall = $userpicture->get_url($PAGE)->out(false);
576             // Set online status indicators.
577             $data->isonline = false;
578             $data->showonlinestatus = false;
579             if (!$member->deleted) {
580                 $data->isonline = self::show_online_status($member) ? self::is_online($member->lastaccess) : null;
581                 $data->showonlinestatus = is_null($data->isonline) ? false : true;
582             }
584             // Set contact and blocked status indicators.
585             $data->iscontact = ($member->contactid) ? true : false;
587             // We don't want that a user has been blocked if they can message the user anyways.
588             $canmessageifblocked = api::can_send_message($referenceuserid, $member->id, true);
589             $data->isblocked = ($member->blockedid && !$canmessageifblocked) ? true : false;
591             $data->isdeleted = ($member->deleted) ? true : false;
593             $data->requirescontact = null;
594             $data->canmessage = null;
595             $data->canmessageevenifblocked = null;
596             if ($includeprivacyinfo) {
597                 $privacysetting = api::get_user_privacy_messaging_preference($member->id);
598                 $data->requirescontact = $privacysetting == api::MESSAGE_PRIVACY_ONLYCONTACTS;
600                 // Here we check that if the sender wanted to block the recipient, the
601                 // recipient would still be able to message them regardless.
602                 $data->canmessageevenifblocked = !$data->isdeleted && $canmessageifblocked;
603                 $data->canmessage = !$data->isdeleted && api::can_send_message($member->id, $referenceuserid);
604             }
606             // Populate the contact requests, even if we don't need them.
607             $data->contactrequests = [];
609             $members[$data->id] = $data;
610         }
612         // Check if we want to include contact requests as well.
613         if (!empty($members) && $includecontactrequests) {
614             list($useridsql, $usersparams) = $DB->get_in_or_equal($userids);
616             $wheresql = "(userid $useridsql AND requesteduserid = ?) OR (userid = ? AND requesteduserid $useridsql)";
617             $params = array_merge($usersparams, [$referenceuserid, $referenceuserid], $usersparams);
618             if ($contactrequests = $DB->get_records_select('message_contact_requests', $wheresql, $params,
619                     'timecreated ASC, id ASC')) {
620                 foreach ($contactrequests as $contactrequest) {
621                     if (isset($members[$contactrequest->userid])) {
622                         $members[$contactrequest->userid]->contactrequests[] = $contactrequest;
623                     }
624                     if (isset($members[$contactrequest->requesteduserid])) {
625                         $members[$contactrequest->requesteduserid]->contactrequests[] = $contactrequest;
626                     }
627                 }
628             }
629         }
631         // Remove any userids not in $members. This can happen in the case of a user who has been deleted
632         // from the Moodle database table (which can happen in earlier versions of Moodle).
633         $userids = array_filter($userids, function($userid) use ($members) {
634             return isset($members[$userid]);
635         });
637         // Return member information in the same order as the userids originally provided.
638         $members = array_replace(array_flip($userids), $members);
640         return $members;
641     }
643     /**
644      * Backwards compatibility formatter, transforming the new output of get_conversations() into the old format.
645      *
646      * TODO: This function should be removed once the related web services go through final deprecation.
647      * The related web services are data_for_messagearea_conversations.
648      * Followup: MDL-63261
649      *
650      * @param array $conversations the array of conversations, which must come from get_conversations().
651      * @return array the array of conversations, formatted in the legacy style.
652      */
653     public static function get_conversations_legacy_formatter(array $conversations) : array {
654         // Transform new data format back into the old format, just for BC during the deprecation life cycle.
655         $tmp = [];
656         foreach ($conversations as $id => $conv) {
657             // Only individual conversations were supported in legacy messaging.
658             if ($conv->type != \core_message\api::MESSAGE_CONVERSATION_TYPE_INDIVIDUAL) {
659                 continue;
660             }
661             $data = new \stdClass();
662             // The logic for the 'other user' is as follows:
663             // If a conversation is of type 'individual', the other user is always the member who is not the current user.
664             // If the conversation is of type 'group', the other user is always the sender of the most recent message.
665             // The get_conversations method already follows this logic, so we just need the first member.
666             $otheruser = reset($conv->members);
667             $data->userid = $otheruser->id;
668             $data->useridfrom = $conv->messages[0]->useridfrom ?? null;
669             $data->fullname = $conv->members[$otheruser->id]->fullname;
670             $data->profileimageurl = $conv->members[$otheruser->id]->profileimageurl;
671             $data->profileimageurlsmall = $conv->members[$otheruser->id]->profileimageurlsmall;
672             $data->ismessaging = isset($conv->messages[0]->text) ? true : false;
673             $data->lastmessage = $conv->messages[0]->text ? clean_param($conv->messages[0]->text, PARAM_NOTAGS) : null;
674             $data->lastmessagedate = $conv->messages[0]->timecreated ?? null;
675             $data->messageid = $conv->messages[0]->id ?? null;
676             $data->isonline = $conv->members[$otheruser->id]->isonline ?? null;
677             $data->isblocked = $conv->members[$otheruser->id]->isblocked ?? null;
678             $data->isread = $conv->isread;
679             $data->unreadcount = $conv->unreadcount;
680             $tmp[$data->userid] = $data;
681         }
682         return $tmp;
683     }
685     /**
686      * Renders the messaging widget.
687      *
688      * @param bool $isdrawer Are we are rendering the drawer or is this on a full page?
689      * @param int|null $sendtouser The ID of the user we want to send a message to
690      * @param int|null $conversationid The ID of the conversation we want to load
691      * @param string|null $view The first view to load in the message widget
692      * @return string The HTML.
693      */
694     public static function render_messaging_widget(
695         bool $isdrawer,
696         int $sendtouser = null,
697         int $conversationid = null,
698         string $view = null
699     ) {
700         global $USER, $CFG, $PAGE;
702         // Early bail out conditions.
703         if (empty($CFG->messaging) || !isloggedin() || isguestuser() || user_not_fully_set_up($USER) ||
704             get_user_preferences('auth_forcepasswordchange') ||
705             (!$USER->policyagreed && !is_siteadmin() &&
706                 ($manager = new \core_privacy\local\sitepolicy\manager()) && $manager->is_defined())) {
707             return '';
708         }
710         $renderer = $PAGE->get_renderer('core');
711         $requestcount = \core_message\api::get_received_contact_requests_count($USER->id);
712         $contactscount = \core_message\api::count_contacts($USER->id);
714         $choices = [];
715         $choices[] = [
716             'value' => \core_message\api::MESSAGE_PRIVACY_ONLYCONTACTS,
717             'text' => get_string('contactableprivacy_onlycontacts', 'message')
718         ];
719         $choices[] = [
720             'value' => \core_message\api::MESSAGE_PRIVACY_COURSEMEMBER,
721             'text' => get_string('contactableprivacy_coursemember', 'message')
722         ];
723         if (!empty($CFG->messagingallusers)) {
724             // Add the MESSAGE_PRIVACY_SITE option when site-wide messaging between users is enabled.
725             $choices[] = [
726                 'value' => \core_message\api::MESSAGE_PRIVACY_SITE,
727                 'text' => get_string('contactableprivacy_site', 'message')
728             ];
729         }
731         // Enter to send.
732         $entertosend = get_user_preferences('message_entertosend', $CFG->messagingdefaultpressenter, $USER);
734         $notification = '';
735         if (!get_user_preferences('core_message_migrate_data', false)) {
736             $notification = get_string('messagingdatahasnotbeenmigrated', 'message');
737         }
739         if ($isdrawer) {
740             $template = 'core_message/message_drawer';
741             $messageurl = new \moodle_url('/message/index.php');
742         } else {
743             $template = 'core_message/message_index';
744             $messageurl = null;
745         }
747         $templatecontext = [
748             'contactrequestcount' => $requestcount,
749             'loggedinuser' => [
750                 'id' => $USER->id,
751                 'midnight' => usergetmidnight(time())
752             ],
753             // The starting timeout value for message polling.
754             'messagepollmin' => $CFG->messagingminpoll ?? MESSAGE_DEFAULT_MIN_POLL_IN_SECONDS,
755             // The maximum value that message polling timeout can reach.
756             'messagepollmax' => $CFG->messagingmaxpoll ?? MESSAGE_DEFAULT_MAX_POLL_IN_SECONDS,
757             // The timeout to reset back to after the max polling time has been reached.
758             'messagepollaftermax' => $CFG->messagingtimeoutpoll ?? MESSAGE_DEFAULT_TIMEOUT_POLL_IN_SECONDS,
759             'contacts' => [
760                 'sectioncontacts' => [
761                     'placeholders' => array_fill(0, $contactscount > 50 ? 50 : $contactscount, true)
762                 ],
763                 'sectionrequests' => [
764                     'placeholders' => array_fill(0, $requestcount > 50 ? 50 : $requestcount, true)
765                 ],
766             ],
767             'settings' => [
768                 'privacy' => $choices,
769                 'entertosend' => $entertosend
770             ],
771             'overview' => [
772                 'messageurl' => $messageurl,
773                 'notification' => $notification
774             ],
775             'isdrawer' => $isdrawer,
776             'showemojipicker' => !empty($CFG->allowemojipicker)
777         ];
779         if ($sendtouser || $conversationid) {
780             $route = [
781                 'path' => 'view-conversation',
782                 'params' => $conversationid ? [$conversationid] : [null, 'create', $sendtouser]
783             ];
784         } else if ($view === 'contactrequests') {
785             $route = [
786                 'path' => 'view-contacts',
787                 'params' => ['requests']
788             ];
789         } else {
790             $route = null;
791         }
793         $templatecontext['route'] = json_encode($route);
795         return $renderer->render_from_template($template, $templatecontext);
796     }
798     /**
799      * Returns user details for a user, if they are visible to the current user in the message search.
800      *
801      * This method checks the visibility of a user specifically for the purpose of inclusion in the message search results.
802      * Visibility depends on the site-wide messaging setting 'messagingallusers':
803      * If enabled, visibility depends only on the core notion of visibility; a visible site or course profile.
804      * If disabled, visibility requires that the user be sharing a course with the searching user, and have a visible profile there.
805      * The current user is always returned.
806      *
807      * @param \stdClass $user
808      * @return array the array of userdetails, if visible, or an empty array otherwise.
809      */
810     public static function search_get_user_details(\stdClass $user) : array {
811         global $CFG, $USER;
812         require_once($CFG->dirroot . '/user/lib.php');
814         if ($CFG->messagingallusers || $user->id == $USER->id) {
815             return \user_get_user_details_courses($user) ?? []; // This checks visibility of site and course profiles.
816         } else {
817             // Messaging specific: user must share a course with the searching user AND have a visible profile there.
818             $sharedcourses = enrol_get_shared_courses($USER, $user);
819             foreach ($sharedcourses as $course) {
820                 if (user_can_view_profile($user, $course)) {
821                     $userdetails = user_get_user_details($user, $course);
822                     if (!is_null($userdetails)) {
823                         return $userdetails;
824                     }
825                 }
826             }
827         }
828         return [];
829     }