7e7e6c4d1638f9e42f4e48ec9941a25f6d9002e0
[moodle.git] / lib / classes / message / manager.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  * New messaging manager class.
19  *
20  * @package   core_message
21  * @since     Moodle 2.8
22  * @copyright 2014 Totara Learning Solutions Ltd {@link http://www.totaralms.com/}
23  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  * @author    Petr Skoda <petr.skoda@totaralms.com>
25  */
27 namespace core\message;
29 defined('MOODLE_INTERNAL') || die();
31 /**
32  * Class used for various messaging related stuff.
33  *
34  * Note: Do NOT use directly in your code, it is intended to be used from core code only.
35  *
36  * @access private
37  *
38  * @package   core_message
39  * @since     Moodle 2.8
40  * @copyright 2014 Totara Learning Solutions Ltd {@link http://www.totaralms.com/}
41  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
42  * @author    Petr Skoda <petr.skoda@totaralms.com>
43  */
44 class manager {
45     /** @var array buffer of pending messages */
46     protected static $buffer = array();
48     /** @var array buffer of pending messages to conversations */
49     protected static $convmessagebuffer = array();
51     /**
52      * Used for calling processors, and generating event data when sending a message to a conversation.
53      *
54      * This is ONLY used for messages of type 'message' (notification=0), and is responsible for:
55      *
56      * 1. generation of per-user event data (to pass to processors)
57      * 2. generation of the processors for each recipient member of the conversation
58      * 3. calling said processors for each member, passing in the per-user (local) eventdata.
59      * 4. generation of an appropriate event for the message send, depending on the conversation type
60      *   - messages to individual conversations generate a 'message_sent' event (as per legacy send_message())
61      *   - messages to group conversations generate a 'group_message_sent' event.
62      *
63      * @param message $eventdata
64      * @param \stdClass $savemessage
65      * @return int
66      */
67     public static function send_message_to_conversation(message $eventdata, \stdClass $savemessage) : int {
68         global $DB, $CFG, $SITE;
70         if (empty($eventdata->convid)) {
71             throw new \moodle_exception("Message is not being sent to a conversation. Please check event data.");
72         }
74         // Fetch default (site) preferences.
75         $defaultpreferences = get_message_output_default_preferences();
76         $preferencebase = $eventdata->component.'_'.$eventdata->name;
78         // Because we're dealing with multiple recipients, we need to send a localised (per-user) version of the eventdata to each
79         // processor, because of things like the language-specific subject. We're going to modify this, for each recipient member.
80         // Any time we're modifying the event data here, we should be using the localised version.
81         // This localised version is based on the generic event data, but we should keep that object intact, so we clone it.
82         $localisedeventdata = clone $eventdata;
84         // Get user records for all members of the conversation.
85         // We must fetch distinct users, because it's possible for a user to message themselves via bulk user actions.
86         // In such cases, there will be 2 records referring to the same user.
87         $sql = "SELECT u.*, mca.id as ismuted
88                   FROM {user} u
89              LEFT JOIN {message_conversation_actions} mca
90                     ON mca.userid = u.id AND mca.conversationid = ? AND mca.action = ?
91                  WHERE u.id IN (
92                           SELECT mcm.userid FROM {message_conversation_members} mcm
93                            WHERE mcm.conversationid = ?
94                  )";
95         $members = $DB->get_records_sql($sql, [$eventdata->convid, \core_message\api::CONVERSATION_ACTION_MUTED,
96             $eventdata->convid]);
97         if (empty($members)) {
98             throw new \moodle_exception("Conversation has no members or does not exist.");
99         }
101         if (!is_object($localisedeventdata->userfrom)) {
102             $localisedeventdata->userfrom = $members[$localisedeventdata->userfrom];
103         }
105         // This should now hold only the other users (recipients).
106         unset($members[$localisedeventdata->userfrom->id]);
107         $otherusers = $members;
109         // Get conversation type and name. We'll use this to determine which message subject to generate, depending on type.
110         $conv = $DB->get_record('message_conversations', ['id' => $eventdata->convid], 'id, type, name');
112         // For now Self conversations are not processed because users are aware of the messages sent by themselves, so we
113         // can return early.
114         if ($conv->type == \core_message\api::MESSAGE_CONVERSATION_TYPE_SELF) {
115             return $savemessage->id;
116         }
117         $localisedeventdata->conversationtype = $conv->type;
119         // We treat individual conversations the same as any direct message with 'userfrom' and 'userto' specified.
120         // We know the other user, so set the 'userto' field so that the event code will get access to this field.
121         // If this was a legacy caller (eventdata->userto is set), then use that instead, as we want to use the fields specified
122         // in that object instead of using one fetched from the DB.
123         $legacymessage = false;
124         if ($conv->type == \core_message\api::MESSAGE_CONVERSATION_TYPE_INDIVIDUAL) {
125             if (isset($eventdata->userto)) {
126                 $legacymessage = true;
127             } else {
128                 $otheruser = reset($otherusers);
129                 $eventdata->userto = $otheruser;
130             }
131         }
133         // Fetch enabled processors.
134         // If we are dealing with a message some processors may want to handle it regardless of user and site settings.
135         $processors = array_filter(get_message_processors(false), function($processor) {
136             if ($processor->object->force_process_messages()) {
137                 return true;
138             }
140             return ($processor->enabled && $processor->configured);
141         });
143         // For each member of the conversation, other than the sender:
144         // 1. Set recipient specific event data (language specific, user prefs, etc)
145         // 2. Generate recipient specific processor list
146         // 3. Call send_message() to pass the message to processors and generate the relevant per-user events.
147         $eventprocmaps = []; // Init the event/processors buffer.
148         foreach ($otherusers as $recipient) {
149             // If this message was a legacy (1:1) message, then we use the userto.
150             if ($legacymessage) {
151                 $ismuted = $recipient->ismuted;
153                 $recipient = $eventdata->userto;
154                 $recipient->ismuted = $ismuted;
155             }
157             $usertoisrealuser = (\core_user::is_real_user($recipient->id) != false);
159             // Using string manager directly so that strings in the message will be in the message recipients language rather than
160             // the sender's.
161             if ($conv->type == \core_message\api::MESSAGE_CONVERSATION_TYPE_INDIVIDUAL) {
162                 $localisedeventdata->subject = get_string_manager()->get_string('unreadnewmessage', 'message',
163                     fullname($localisedeventdata->userfrom), $recipient->lang);
164             } else if ($conv->type == \core_message\api::MESSAGE_CONVERSATION_TYPE_GROUP) {
165                 $stringdata = (object) ['name' => fullname($localisedeventdata->userfrom), 'conversationname' => $conv->name];
166                 $localisedeventdata->subject = get_string_manager()->get_string('unreadnewgroupconversationmessage', 'message',
167                     $stringdata, $recipient->lang);
168             }
170             // Spoof the userto based on the current member id.
171             $localisedeventdata->userto = $recipient;
172             // Check if the notification is including images that will need a user token to be displayed outside Moodle.
173             if (!empty($localisedeventdata->customdata)) {
174                 $customdata = json_decode($localisedeventdata->customdata);
175                 if (is_object($customdata) && !empty($customdata->notificationiconurl)) {
176                     $customdata->tokenpluginfile = get_user_key('core_files', $localisedeventdata->userto->id);
177                     $localisedeventdata->customdata = $customdata; // Message class will JSON encode again.
178                 }
179             }
181             $s = new \stdClass();
182             $s->sitename = format_string($SITE->shortname, true, array('context' => \context_course::instance(SITEID)));
183             $s->url = $CFG->wwwroot.'/message/index.php?id='.$eventdata->userfrom->id;
184             $emailtagline = get_string_manager()->get_string('emailtagline', 'message', $s, $recipient->lang);
186             $localisedeventdata->fullmessage = $eventdata->fullmessage;
187             $localisedeventdata->fullmessagehtml = $eventdata->fullmessagehtml;
188             if (!empty($localisedeventdata->fullmessage)) {
189                 // Prevent unclosed HTML elements.
190                 $localisedeventdata->fullmessage =
191                     \core_message\helper::prevent_unclosed_html_tags($localisedeventdata->fullmessage, true);
193                 $localisedeventdata->fullmessage .= "\n\n---------------------------------------------------------------------\n"
194                     . $emailtagline;
195             }
196             if (!empty($localisedeventdata->fullmessagehtml)) {
197                 // Prevent unclosed HTML elements.
198                 $localisedeventdata->fullmessagehtml =
199                     \core_message\helper::prevent_unclosed_html_tags($localisedeventdata->fullmessagehtml, true);
201                 $localisedeventdata->fullmessagehtml .=
202                     "<br><br>---------------------------------------------------------------------<br>" . $emailtagline;
203             }
205             // If recipient is internal user (noreply user), and emailstop is set then don't send any msg.
206             if (!$usertoisrealuser && !empty($recipient->emailstop)) {
207                 debugging('Attempt to send msg to internal (noreply) user', DEBUG_NORMAL);
208                 return false;
209             }
211             // Set the online state.
212             if (isset($CFG->block_online_users_timetosee)) {
213                 $timetoshowusers = $CFG->block_online_users_timetosee * 60;
214             } else {
215                 $timetoshowusers = 300;
216             }
218             // Work out if the user is logged in or not.
219             $userstate = 'loggedoff';
220             if (!empty($localisedeventdata->userto->lastaccess)
221                     && (time() - $timetoshowusers) < $localisedeventdata->userto->lastaccess) {
222                 $userstate = 'loggedin';
223             }
225             // Fill in the array of processors to be used based on default and user preferences.
226             // Do not process muted conversations.
227             $processorlist = [];
228             if (!$recipient->ismuted) {
229                 foreach ($processors as $processor) {
230                     // Skip adding processors for internal user, if processor doesn't support sending message to internal user.
231                     if (!$usertoisrealuser && !$processor->object->can_send_to_any_users()) {
232                         continue;
233                     }
235                     // First find out permissions.
236                     $defaultpreference = $processor->name . '_provider_' . $preferencebase . '_permitted';
237                     if (isset($defaultpreferences->{$defaultpreference})) {
238                         $permitted = $defaultpreferences->{$defaultpreference};
239                     } else {
240                         // MDL-25114 They supplied an $eventdata->component $eventdata->name combination which doesn't
241                         // exist in the message_provider table (thus there is no default settings for them).
242                         $preferrormsg = "Could not load preference $defaultpreference. Make sure the component and name you supplied
243                     to message_send() are valid.";
244                         throw new coding_exception($preferrormsg);
245                     }
247                     // Find out if user has configured this output.
248                     // Some processors cannot function without settings from the user.
249                     $userisconfigured = $processor->object->is_user_configured($recipient);
251                     // DEBUG: notify if we are forcing unconfigured output.
252                     if ($permitted == 'forced' && !$userisconfigured) {
253                         debugging('Attempt to force message delivery to user who has "' . $processor->name .
254                             '" output unconfigured', DEBUG_NORMAL);
255                     }
257                     // Populate the list of processors we will be using.
258                     if (!$eventdata->notification && $processor->object->force_process_messages()) {
259                         $processorlist[] = $processor->name;
260                     } else if ($permitted == 'forced' && $userisconfigured) {
261                         // An admin is forcing users to use this message processor. Use this processor unconditionally.
262                         $processorlist[] = $processor->name;
263                     } else if ($permitted == 'permitted' && $userisconfigured && !$recipient->emailstop) {
264                         // User has not disabled notifications.
265                         // See if user set any notification preferences, otherwise use site default ones.
266                         $userpreferencename = 'message_provider_' . $preferencebase . '_' . $userstate;
267                         if ($userpreference = get_user_preferences($userpreferencename, null, $recipient)) {
268                             if (in_array($processor->name, explode(',', $userpreference))) {
269                                 $processorlist[] = $processor->name;
270                             }
271                         } else if (isset($defaultpreferences->{$userpreferencename})) {
272                             if (in_array($processor->name, explode(',', $defaultpreferences->{$userpreferencename}))) {
273                                 $processorlist[] = $processor->name;
274                             }
275                         }
276                     }
277                 }
278             }
279             // Batch up the localised event data and processor list for all users into a local buffer.
280             $eventprocmaps[] = [clone($localisedeventdata), $processorlist];
281         }
282         // Then pass it off as one item of work, to be processed by send_conversation_message_to_processors(), which will
283         // handle all transaction buffering logic.
284         self::send_conversation_message_to_processors($eventprocmaps, $eventdata, $savemessage);
286         return $savemessage->id;
287     }
289     /**
290      * Takes a list of localised event data, and tries to send them to their respective member's message processors.
291      *
292      * Input format:
293      *  [CONVID => [$localisedeventdata, $savemessage, $processorlist], ].
294      *
295      * @param array $eventprocmaps the array of localised event data and processors for each member of the conversation.
296      * @param message $eventdata the original conversation message eventdata
297      * @param \stdClass $savemessage the saved message record.
298      * @throws \coding_exception
299      */
300     protected static function send_conversation_message_to_processors(array $eventprocmaps, message $eventdata,
301                                                                       \stdClass $savemessage) {
302         global $DB;
304         // We cannot communicate with external systems in DB transactions,
305         // buffer the messages if necessary.
306         if ($DB->is_transaction_started()) {
307             // Buffer this group conversation message and it's record.
308             self::$convmessagebuffer[] = [$eventprocmaps, $eventdata, $savemessage];
309             return;
310         }
312         // Send each localised version of the event data to each member's respective processors.
313         foreach ($eventprocmaps as $eventprocmap) {
314             $eventdata = $eventprocmap[0];
315             $processorlist = $eventprocmap[1];
316             self::call_processors($eventdata, $processorlist);
317         }
319         // Trigger event for sending a message or notification - we need to do this before marking as read!
320         self::trigger_message_events($eventdata, $savemessage);
321     }
323     /**
324      * Do the message sending.
325      *
326      * NOTE: to be used from message_send() only.
327      *
328      * @param \core\message\message $eventdata fully prepared event data for processors
329      * @param \stdClass $savemessage the message saved in 'message' table
330      * @param array $processorlist list of processors for target user
331      * @return int $messageid the id from 'messages' (false is not returned)
332      */
333     public static function send_message(message $eventdata, \stdClass $savemessage, array $processorlist) {
334         global $CFG;
336         require_once($CFG->dirroot.'/message/lib.php'); // This is most probably already included from messagelib.php file.
338         if (empty($processorlist)) {
339             // Trigger event for sending a message or notification - we need to do this before marking as read!
340             self::trigger_message_events($eventdata, $savemessage);
342             if ($eventdata->notification) {
343                 // If they have deselected all processors and it's a notification mark it read. The user doesn't want to be
344                 // bothered.
345                 $savemessage->timeread = null;
346                 \core_message\api::mark_notification_as_read($savemessage);
347             } else if (empty($CFG->messaging)) {
348                 // If it's a message and messaging is disabled mark it read.
349                 \core_message\api::mark_message_as_read($eventdata->userto->id, $savemessage);
350             }
352             return $savemessage->id;
353         }
355         // Let the manager do the sending or buffering when db transaction in progress.
356         return self::send_message_to_processors($eventdata, $savemessage, $processorlist);
357     }
359     /**
360      * Send message to message processors.
361      *
362      * @param \stdClass|\core\message\message $eventdata
363      * @param \stdClass $savemessage
364      * @param array $processorlist
365      * @return int $messageid
366      */
367     protected static function send_message_to_processors($eventdata, \stdClass $savemessage, array
368     $processorlist) {
369         global $CFG, $DB;
371         // We cannot communicate with external systems in DB transactions,
372         // buffer the messages if necessary.
373         if ($DB->is_transaction_started()) {
374             // We need to clone all objects so that devs may not modify it from outside later.
375             $eventdata = clone($eventdata);
376             $eventdata->userto = clone($eventdata->userto);
377             $eventdata->userfrom = clone($eventdata->userfrom);
379             // Conserve some memory the same was as $USER setup does.
380             unset($eventdata->userto->description);
381             unset($eventdata->userfrom->description);
383             self::$buffer[] = array($eventdata, $savemessage, $processorlist);
384             return $savemessage->id;
385         }
387         // Send the message to processors.
388         self::call_processors($eventdata, $processorlist);
390         // Trigger event for sending a message or notification - we need to do this before marking as read!
391         self::trigger_message_events($eventdata, $savemessage);
393         if (!$eventdata->notification && empty($CFG->messaging)) {
394             // If it's a message and messaging is disabled mark it read.
395             \core_message\api::mark_message_as_read($eventdata->userto->id, $savemessage);
396         }
398         return $savemessage->id;
399     }
401     /**
402      * Notification from DML layer.
403      *
404      * Note: to be used from DML layer only.
405      */
406     public static function database_transaction_commited() {
407         if (!self::$buffer && !self::$convmessagebuffer) {
408             return;
409         }
410         self::process_buffer();
411     }
413     /**
414      * Notification from DML layer.
415      *
416      * Note: to be used from DML layer only.
417      */
418     public static function database_transaction_rolledback() {
419         self::$buffer = array();
420         self::$convmessagebuffer = array();
421     }
423     /**
424      * Sent out any buffered messages if necessary.
425      */
426     protected static function process_buffer() {
427         // Reset the buffers first in case we get exception from processor.
428         $messages = self::$buffer;
429         self::$buffer = array();
430         $convmessages = self::$convmessagebuffer;
431         self::$convmessagebuffer = array();
433         foreach ($messages as $message) {
434             list($eventdata, $savemessage, $processorlist) = $message;
435             self::send_message_to_processors($eventdata, $savemessage, $processorlist);
436         }
438         foreach ($convmessages as $convmessage) {
439             list($eventprocmap, $eventdata, $savemessage) = $convmessage;
440             self::send_conversation_message_to_processors($eventprocmap, $eventdata, $savemessage);
441         }
442     }
444     /**
445      * Trigger an appropriate message creation event, based on the supplied $eventdata and $savemessage.
446      *
447      * @param message $eventdata the eventdata for the message.
448      * @param \stdClass $savemessage the message record.
449      * @throws \coding_exception
450      */
451     protected static function trigger_message_events(message $eventdata, \stdClass $savemessage) {
452         global $DB;
453         if ($eventdata->notification) {
454             \core\event\notification_sent::create_from_ids(
455                 $eventdata->userfrom->id,
456                 $eventdata->userto->id,
457                 $savemessage->id,
458                 $eventdata->courseid
459             )->trigger();
460         } else { // Must be a message.
461             // If the message is a group conversation, then trigger the 'group_message_sent' event.
462             if ($eventdata->convid) {
463                 $conv = $DB->get_record('message_conversations', ['id' => $eventdata->convid], 'id, type');
464                 if ($conv->type == \core_message\api::MESSAGE_CONVERSATION_TYPE_GROUP) {
465                     \core\event\group_message_sent::create_from_ids(
466                         $eventdata->userfrom->id,
467                         $eventdata->convid,
468                         $savemessage->id,
469                         $eventdata->courseid
470                     )->trigger();
471                     return;
472                 }
473                 // Individual type conversations fall through to the default 'message_sent' event.
474             }
475             \core\event\message_sent::create_from_ids(
476                 $eventdata->userfrom->id,
477                 $eventdata->userto->id,
478                 $savemessage->id,
479                 $eventdata->courseid
480             )->trigger();
481         }
482     }
484     /**
485      * For each processor, call it's send_message() method.
486      *
487      * @param message $eventdata the message object.
488      * @param array $processorlist the list of processors for a single user.
489      */
490     protected static function call_processors(message $eventdata, array $processorlist) {
491         // Allow plugins to change the message/notification data before sending it.
492         $pluginsfunction = get_plugins_with_function('pre_processor_message_send');
494         foreach ($processorlist as $procname) {
495             // Let new messaging class add custom content based on the processor.
496             $proceventdata = ($eventdata instanceof message) ? $eventdata->get_eventobject_for_processor($procname) : $eventdata;
498             if ($pluginsfunction) {
499                 foreach ($pluginsfunction as $plugintype => $plugins) {
500                     foreach ($plugins as $pluginfunction) {
501                         $pluginfunction($procname, $proceventdata);
502                     }
503                 }
504             }
506             $stdproc = new \stdClass();
507             $stdproc->name = $procname;
508             $processor = \core_message\api::get_processed_processor_object($stdproc);
509             if (!$processor->object->send_message($proceventdata)) {
510                 debugging('Error calling message processor ' . $procname);
511             }
512         }
513     }