MDL-58650 core_message: always use 'popup' processor for messages
[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         $failed = false;
137         foreach ($processorlist as $procname) {
138             // Let new messaging class add custom content based on the processor.
139             $proceventdata = ($eventdata instanceof message) ? $eventdata->get_eventobject_for_processor($procname) : $eventdata;
140             $stdproc = new \stdClass();
141             $stdproc->name = $procname;
142             $processor = \core_message\api::get_processed_processor_object($stdproc);
143             if (!$processor->object->send_message($proceventdata)) {
144                 debugging('Error calling message processor ' . $procname);
145                 $failed = true;
146                 // Previously the $messageid = false here was overridden
147                 // by other processors and message_mark_message_read() below.
148             }
149         }
151         // Trigger event for sending a message - must be done before marking as read.
152         \core\event\message_sent::create_from_ids(
153             $eventdata->userfrom->id,
154             $eventdata->userto->id,
155             $savemessage->id,
156             $eventdata->courseid
157             )->trigger();
159         if (empty($CFG->messaging)) {
160             // If messaging is disabled and they previously had forum notifications handled by the popup processor
161             // or any processor that puts a row in message_working then the notification will remain forever
162             // unread. To prevent this mark the message read if messaging is disabled.
163             $messageid = message_mark_message_read($savemessage, time());
165         } else if ($failed) {
166             // Something failed, better keep it as unread then.
167             $messageid = $savemessage->id;
169         } else if ($DB->count_records('message_working', array('unreadmessageid' => $savemessage->id)) == 0) {
170             // If there is no more processors that want to process this we can move message to message_read.
171             $messageid = message_mark_message_read($savemessage, time(), true);
173         } else {
174             // Some processor is still working on the data, let's keep it unread.
175             $messageid = $savemessage->id;
176         }
178         return $messageid;
179     }
181     /**
182      * Notification from DML layer.
183      *
184      * Note: to be used from DML layer only.
185      */
186     public static function database_transaction_commited() {
187         if (!self::$buffer) {
188             return;
189         }
190         self::process_buffer();
191     }
193     /**
194      * Notification from DML layer.
195      *
196      * Note: to be used from DML layer only.
197      */
198     public static function database_transaction_rolledback() {
199         self::$buffer = array();
200     }
202     /**
203      * Sent out any buffered messages if necessary.
204      */
205     protected static function process_buffer() {
206         // Reset the buffer first in case we get exception from processor.
207         $messages = self::$buffer;
208         self::$buffer = array();
210         foreach ($messages as $message) {
211             list($eventdata, $savemessage, $processorlist) = $message;
212             self::send_message_to_processors($eventdata, $savemessage, $processorlist);
213         }
214     }