MDL-47162 core_message: debug whenever courseid is missing
[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     /**
49      * Do the message sending.
50      *
51      * NOTE: to be used from message_send() only.
52      *
53      * @todo MDL-55449 Drop support for stdClass in Moodle 3.6
54      * @param \core\message\message $eventdata fully prepared event data for processors
55      * @param \stdClass $savemessage the message saved in 'message' table
56      * @param array $processorlist list of processors for target user
57      * @return int $messageid the id from 'message' or 'message_read' table (false is not returned)
58      */
59     public static function send_message($eventdata, \stdClass $savemessage, array $processorlist) {
60         global $CFG;
62         // TODO MDL-55449 Drop support for stdClass in Moodle 3.6.
63         if (!($eventdata instanceof \stdClass) && !($eventdata instanceof message)) {
64             // Not a valid object.
65             throw new \coding_exception('Message should be of type stdClass or \core\message\message');
66         }
68         // TODO MDL-55449 Drop support for stdClass in Moodle 3.6.
69         if ($eventdata instanceof \stdClass) {
70             if (!isset($eventdata->courseid)) {
71                 $eventdata->courseid = null;
72             }
74             debugging('eventdata as \stdClass is deprecated. Please use \core\message\message instead.', DEBUG_DEVELOPER);
75         }
77         require_once($CFG->dirroot.'/message/lib.php'); // This is most probably already included from messagelib.php file.
79         if (empty($processorlist)) {
80             // Trigger event for sending a message - we need to do this before marking as read!
81             \core\event\message_sent::create_from_ids(
82                 $eventdata->userfrom->id,
83                 $eventdata->userto->id,
84                 $savemessage->id,
85                 $eventdata->courseid
86                 )->trigger();
88             if ($savemessage->notification or empty($CFG->messaging)) {
89                 // If they have deselected all processors and its a notification mark it read. The user doesn't want to be bothered.
90                 // The same goes if the messaging is completely disabled.
91                 // We cannot insert directly to the message_read table because we want to get all events in proper order!
92                 $messageid = message_mark_message_read($savemessage, time(), true);
94             } else {
95                 // Just add it to the list of unread messages, there is no way it could be delivered to them,
96                 // but they can read it via the messaging UI later.
97                 $messageid = $savemessage->id;
98             }
100             return $messageid;
101         }
103         // Let the manager do the sending or buffering when db transaction in progress.
104         return self::send_message_to_processors($eventdata, $savemessage, $processorlist);
105     }
107     /**
108      * Send message to message processors.
109      *
110      * @param \stdClass|\core\message\message $eventdata
111      * @param \stdClass $savemessage
112      * @param array $processorlist
113      * @return int $messageid
114      */
115     protected static function send_message_to_processors($eventdata, \stdClass $savemessage, array
116     $processorlist) {
117         global $CFG, $DB;
119         // We cannot communicate with external systems in DB transactions,
120         // buffer the messages if necessary.
122         if ($DB->is_transaction_started()) {
123             // We need to clone all objects so that devs may not modify it from outside later.
124             $eventdata = clone($eventdata);
125             $eventdata->userto = clone($eventdata->userto);
126             $eventdata->userfrom = clone($eventdata->userfrom);
128             // Conserve some memory the same was as $USER setup does.
129             unset($eventdata->userto->description);
130             unset($eventdata->userfrom->description);
132             self::$buffer[] = array($eventdata, $savemessage, $processorlist);
133             return $savemessage->id;
134         }
136         $processors = get_message_processors(true);
138         $failed = false;
139         foreach ($processorlist as $procname) {
140             // Let new messaging class add custom content based on the processor.
141             $proceventdata = ($eventdata instanceof message) ? $eventdata->get_eventobject_for_processor($procname) : $eventdata;
142             if (!$processors[$procname]->object->send_message($proceventdata)) {
143                 debugging('Error calling message processor ' . $procname);
144                 $failed = true;
145                 // Previously the $messageid = false here was overridden
146                 // by other processors and message_mark_message_read() below.
147             }
148         }
150         // Trigger event for sending a message - must be done before marking as read.
151         \core\event\message_sent::create_from_ids(
152             $eventdata->userfrom->id,
153             $eventdata->userto->id,
154             $savemessage->id,
155             $eventdata->courseid
156             )->trigger();
158         if (empty($CFG->messaging)) {
159             // If messaging is disabled and they previously had forum notifications handled by the popup processor
160             // or any processor that puts a row in message_working then the notification will remain forever
161             // unread. To prevent this mark the message read if messaging is disabled.
162             $messageid = message_mark_message_read($savemessage, time());
164         } else if ($failed) {
165             // Something failed, better keep it as unread then.
166             $messageid = $savemessage->id;
168         } else if ($DB->count_records('message_working', array('unreadmessageid' => $savemessage->id)) == 0) {
169             // If there is no more processors that want to process this we can move message to message_read.
170             $messageid = message_mark_message_read($savemessage, time(), true);
172         } else {
173             // Some processor is still working on the data, let's keep it unread.
174             $messageid = $savemessage->id;
175         }
177         return $messageid;
178     }
180     /**
181      * Notification from DML layer.
182      *
183      * Note: to be used from DML layer only.
184      */
185     public static function database_transaction_commited() {
186         if (!self::$buffer) {
187             return;
188         }
189         self::process_buffer();
190     }
192     /**
193      * Notification from DML layer.
194      *
195      * Note: to be used from DML layer only.
196      */
197     public static function database_transaction_rolledback() {
198         self::$buffer = array();
199     }
201     /**
202      * Sent out any buffered messages if necessary.
203      */
204     protected static function process_buffer() {
205         // Reset the buffer first in case we get exception from processor.
206         $messages = self::$buffer;
207         self::$buffer = array();
209         foreach ($messages as $message) {
210             list($eventdata, $savemessage, $processorlist) = $message;
211             self::send_message_to_processors($eventdata, $savemessage, $processorlist);
212         }
213     }