3008d21594390cab967a0fae59483a1d59e1e159
[moodle.git] / lib / messagelib.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  * Functions for interacting with the message system
19  *
20  * @package   core_message
21  * @copyright 2008 Luis Rodrigues and Martin Dougiamas
22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 defined('MOODLE_INTERNAL') || die();
27 require_once(__DIR__ . '/../message/lib.php');
29 /**
30  * Called when a message provider wants to send a message.
31  * This functions checks the message recipient's message processor configuration then
32  * sends the message to the configured processors
33  *
34  * Required parameters of the $eventdata object:
35  *  component string component name. must exist in message_providers
36  *  name string message type name. must exist in message_providers
37  *  userfrom object|int the user sending the message
38  *  userto object|int the message recipient
39  *  subject string the message subject
40  *  fullmessage string the full message in a given format
41  *  fullmessageformat int the format if the full message (FORMAT_MOODLE, FORMAT_HTML, ..)
42  *  fullmessagehtml string the full version (the message processor will choose with one to use)
43  *  smallmessage string the small version of the message
44  *
45  * Optional parameters of the $eventdata object:
46  *  notification bool should the message be considered as a notification rather than a personal message
47  *  contexturl string if this is a notification then you can specify a url to view the event. For example the forum post the user is being notified of.
48  *  contexturlname string the display text for contexturl
49  *
50  * Note: processor failure is is not reported as false return value,
51  *       earlier versions did not do it consistently either.
52  *
53  * @category message
54  * @param \core\message\message $eventdata information about the message (component, userfrom, userto, ...)
55  * @return mixed the integer ID of the new message or false if there was a problem with submitted data
56  */
57 function message_send(\core\message\message $eventdata) {
58     global $CFG, $DB, $SITE;
60     //new message ID to return
61     $messageid = false;
63     // Fetch default (site) preferences
64     $defaultpreferences = get_message_output_default_preferences();
65     $preferencebase = $eventdata->component.'_'.$eventdata->name;
67     // If the message provider is disabled via preferences, then don't send the message.
68     if (!empty($defaultpreferences->{$preferencebase.'_disable'})) {
69         return $messageid;
70     }
72     // By default a message is a notification. Only personal/private messages aren't notifications.
73     if (!isset($eventdata->notification)) {
74         $eventdata->notification = 1;
75     }
77     if (!is_object($eventdata->userfrom)) {
78         $eventdata->userfrom = core_user::get_user($eventdata->userfrom);
79     }
80     if (!$eventdata->userfrom) {
81         debugging('Attempt to send msg from unknown user', DEBUG_NORMAL);
82         return false;
83     }
85     // Legacy messages (FROM a single user TO a single user) must be converted into conversation messages.
86     // Then, these will be passed through the conversation messages code below.
87     if (!$eventdata->notification && !$eventdata->convid) {
88         // If messaging is disabled at the site level, then the 'instantmessage' provider is always disabled.
89         // Given this is the only 'message' type message provider, we can exit now if this is the case.
90         // Don't waste processing time trying to work out the other conversation member, if it's an individual
91         // conversation, just throw a generic debugging notice and return.
92         if (empty($CFG->messaging) || $eventdata->component !== 'moodle' || $eventdata->name !== 'instantmessage') {
93             debugging('Attempt to send msg from a provider '.$eventdata->component.'/'.$eventdata->name.
94                 ' that is inactive or not allowed for the user id='.$eventdata->userto->id, DEBUG_NORMAL);
95             return false;
96         }
98         if (!is_object($eventdata->userto)) {
99             $eventdata->userto = core_user::get_user($eventdata->userto);
100         }
101         if (!$eventdata->userto) {
102             debugging('Attempt to send msg to unknown user', DEBUG_NORMAL);
103             return false;
104         }
106         // Verify all necessary data fields are present.
107         if (!isset($eventdata->userto->auth) or !isset($eventdata->userto->suspended)
108             or !isset($eventdata->userto->deleted) or !isset($eventdata->userto->emailstop)) {
110             debugging('Necessary properties missing in userto object, fetching full record', DEBUG_DEVELOPER);
111             $eventdata->userto = core_user::get_user($eventdata->userto->id);
112         }
114         $usertoisrealuser = (core_user::is_real_user($eventdata->userto->id) != false);
115         // If recipient is internal user (noreply user), and emailstop is set then don't send any msg.
116         if (!$usertoisrealuser && !empty($eventdata->userto->emailstop)) {
117             debugging('Attempt to send msg to internal (noreply) user', DEBUG_NORMAL);
118             return false;
119         }
121         if (!$conversationid = \core_message\api::get_conversation_between_users([$eventdata->userfrom->id,
122                                                                                   $eventdata->userto->id])) {
123             $conversation = \core_message\api::create_conversation(
124                 \core_message\api::MESSAGE_CONVERSATION_TYPE_INDIVIDUAL,
125                 [
126                     $eventdata->userfrom->id,
127                     $eventdata->userto->id
128                 ]
129             );
130         }
131         // We either have found a conversation, or created one.
132         $conversationid = $conversationid ? $conversationid : $conversation->id;
133         $eventdata->convid = $conversationid;
134     }
136     // This is a message directed to a conversation, not a specific user as was the way in legacy messaging.
137     // The above code has adapted the legacy messages into conversation messages.
138     // We must call send_message_to_conversation(), which handles per-member processor iteration and triggers
139     // a per-conversation event.
140     // All eventdata for messages should now have a convid, as we fixed this above.
141     if (!$eventdata->notification) {
143         // Only one message will be saved to the DB.
144         $conversationid = $eventdata->convid;
145         $table = 'messages';
146         $tabledata = new stdClass();
147         $tabledata->courseid = $eventdata->courseid;
148         $tabledata->useridfrom = $eventdata->userfrom->id;
149         $tabledata->conversationid = $conversationid;
150         $tabledata->subject = $eventdata->subject;
151         $tabledata->fullmessage = $eventdata->fullmessage;
152         $tabledata->fullmessageformat = $eventdata->fullmessageformat;
153         $tabledata->fullmessagehtml = $eventdata->fullmessagehtml;
154         $tabledata->smallmessage = $eventdata->smallmessage;
155         $tabledata->timecreated = time();
157         if (PHPUNIT_TEST and class_exists('phpunit_util')) {
158             // Add some more tests to make sure the normal code can actually work.
159             $componentdir = core_component::get_component_directory($eventdata->component);
160             if (!$componentdir or !is_dir($componentdir)) {
161                 throw new coding_exception('Invalid component specified in message-send(): '.$eventdata->component);
162             }
163             if (!file_exists("$componentdir/db/messages.php")) {
164                 throw new coding_exception("$eventdata->component does not contain db/messages.php necessary for message_send()");
165             }
166             $messageproviders = null;
167             include("$componentdir/db/messages.php");
168             if (!isset($messageproviders[$eventdata->name])) {
169                 $errormsg = "Missing messaging defaults for event '$eventdata->name' in '$eventdata->component' messages.php file";
170                 throw new coding_exception($errormsg);
171             }
172             unset($componentdir);
173             unset($messageproviders);
174             // Now ask phpunit if it wants to catch this message.
175             if (phpunit_util::is_redirecting_messages()) {
176                 $messageid = $DB->insert_record($table, $tabledata);
177                 $message = $DB->get_record($table, array('id' => $messageid));
179                 // Add the useridto attribute for BC.
180                 if (isset($eventdata->userto)) {
181                     $message->useridto = $eventdata->userto->id;
182                 }
184                 // Mark the message as read for each of the other users.
185                 $sql = "SELECT u.*
186                   FROM {message_conversation_members} mcm
187                   JOIN {user} u
188                     ON (mcm.conversationid = :convid AND u.id = mcm.userid AND u.id != :userid)";
189                 $otherusers = $DB->get_records_sql($sql, ['convid' => $eventdata->convid, 'userid' => $eventdata->userfrom->id]);
190                 foreach ($otherusers as $othermember) {
191                     \core_message\api::mark_message_as_read($othermember->id, $message);
192                 }
194                 // Unit tests need this detail.
195                 $message->notification = $eventdata->notification;
196                 phpunit_util::message_sent($message);
197                 return $messageid;
198             }
199         }
201         // Cache messages.
202         if (!empty($eventdata->convid)) {
203             // Cache the timecreated value of the last message in this conversation.
204             $cache = cache::make('core', 'message_time_last_message_between_users');
205             $key = \core_message\helper::get_last_message_time_created_cache_key($eventdata->convid);
206             $cache->set($key, $tabledata->timecreated);
207         }
209         // Store unread message just in case we get a fatal error any time later.
210         $tabledata->id = $DB->insert_record($table, $tabledata);
211         $eventdata->savedmessageid = $tabledata->id;
213         return \core\message\manager::send_message_to_conversation($eventdata, $tabledata);
214     }
216     // Else the message is a notification.
217     if (!is_object($eventdata->userto)) {
218         $eventdata->userto = core_user::get_user($eventdata->userto);
219     }
220     if (!$eventdata->userto) {
221         debugging('Attempt to send msg to unknown user', DEBUG_NORMAL);
222         return false;
223     }
225     // If the provider's component is disabled or the user can't receive messages from it, don't send the message.
226     $isproviderallowed = false;
227     foreach (message_get_providers_for_user($eventdata->userto->id) as $provider) {
228         if ($provider->component === $eventdata->component && $provider->name === $eventdata->name) {
229             $isproviderallowed = true;
230             break;
231         }
232     }
233     if (!$isproviderallowed) {
234         debugging('Attempt to send msg from a provider '.$eventdata->component.'/'.$eventdata->name.
235             ' that is inactive or not allowed for the user id='.$eventdata->userto->id, DEBUG_NORMAL);
236         return false;
237     }
239     // Verify all necessary data fields are present.
240     if (!isset($eventdata->userto->auth) or !isset($eventdata->userto->suspended)
241             or !isset($eventdata->userto->deleted) or !isset($eventdata->userto->emailstop)) {
243         debugging('Necessary properties missing in userto object, fetching full record', DEBUG_DEVELOPER);
244         $eventdata->userto = core_user::get_user($eventdata->userto->id);
245     }
247     $usertoisrealuser = (core_user::is_real_user($eventdata->userto->id) != false);
248     // If recipient is internal user (noreply user), and emailstop is set then don't send any msg.
249     if (!$usertoisrealuser && !empty($eventdata->userto->emailstop)) {
250         debugging('Attempt to send msg to internal (noreply) user', DEBUG_NORMAL);
251         return false;
252     }
254     //after how long inactive should the user be considered logged off?
255     if (isset($CFG->block_online_users_timetosee)) {
256         $timetoshowusers = $CFG->block_online_users_timetosee * 60;
257     } else {
258         $timetoshowusers = 300;//5 minutes
259     }
261     // Work out if the user is logged in or not
262     if (!empty($eventdata->userto->lastaccess) && (time()-$timetoshowusers) < $eventdata->userto->lastaccess) {
263         $userstate = 'loggedin';
264     } else {
265         $userstate = 'loggedoff';
266     }
268     // Check if we are creating a notification or message.
269     $table = 'notifications';
271     $tabledata = new stdClass();
272     $tabledata->useridfrom = $eventdata->userfrom->id;
273     $tabledata->useridto = $eventdata->userto->id;
274     $tabledata->subject = $eventdata->subject;
275     $tabledata->fullmessage = $eventdata->fullmessage;
276     $tabledata->fullmessageformat = $eventdata->fullmessageformat;
277     $tabledata->fullmessagehtml = $eventdata->fullmessagehtml;
278     $tabledata->smallmessage = $eventdata->smallmessage;
279     $tabledata->eventtype = $eventdata->name;
280     $tabledata->component = $eventdata->component;
281     $tabledata->timecreated = time();
282     if (!empty($eventdata->contexturl)) {
283         $tabledata->contexturl = (string)$eventdata->contexturl;
284     } else {
285         $tabledata->contexturl = null;
286     }
288     if (!empty($eventdata->contexturlname)) {
289         $tabledata->contexturlname = (string)$eventdata->contexturlname;
290     } else {
291         $tabledata->contexturlname = null;
292     }
294     if (PHPUNIT_TEST and class_exists('phpunit_util')) {
295         // Add some more tests to make sure the normal code can actually work.
296         $componentdir = core_component::get_component_directory($eventdata->component);
297         if (!$componentdir or !is_dir($componentdir)) {
298             throw new coding_exception('Invalid component specified in message-send(): '.$eventdata->component);
299         }
300         if (!file_exists("$componentdir/db/messages.php")) {
301             throw new coding_exception("$eventdata->component does not contain db/messages.php necessary for message_send()");
302         }
303         $messageproviders = null;
304         include("$componentdir/db/messages.php");
305         if (!isset($messageproviders[$eventdata->name])) {
306             throw new coding_exception("Missing messaging defaults for event '$eventdata->name' in '$eventdata->component' messages.php file");
307         }
308         unset($componentdir);
309         unset($messageproviders);
310         // Now ask phpunit if it wants to catch this message.
311         if (phpunit_util::is_redirecting_messages()) {
312             $messageid = $DB->insert_record($table, $tabledata);
313             $message = $DB->get_record($table, array('id' => $messageid));
315             // Add the useridto attribute for BC.
316             $message->useridto = $eventdata->userto->id;
318             // Mark the notification as read.
319             \core_message\api::mark_notification_as_read($message);
321             // Unit tests need this detail.
322             $message->notification = $eventdata->notification;
323             phpunit_util::message_sent($message);
324             return $messageid;
325         }
326     }
328     // Fetch enabled processors.
329     $processors = get_message_processors(true);
331     // Preset variables
332     $processorlist = array();
333     // Fill in the array of processors to be used based on default and user preferences
334     foreach ($processors as $processor) {
335         // Skip adding processors for internal user, if processor doesn't support sending message to internal user.
336         if (!$usertoisrealuser && !$processor->object->can_send_to_any_users()) {
337             continue;
338         }
340         // First find out permissions
341         $defaultpreference = $processor->name.'_provider_'.$preferencebase.'_permitted';
342         if (isset($defaultpreferences->{$defaultpreference})) {
343             $permitted = $defaultpreferences->{$defaultpreference};
344         } else {
345             // MDL-25114 They supplied an $eventdata->component $eventdata->name combination which doesn't
346             // exist in the message_provider table (thus there is no default settings for them).
347             $preferrormsg = "Could not load preference $defaultpreference. Make sure the component and name you supplied
348                     to message_send() are valid.";
349             throw new coding_exception($preferrormsg);
350         }
352         // Find out if user has configured this output
353         // Some processors cannot function without settings from the user
354         $userisconfigured = $processor->object->is_user_configured($eventdata->userto);
356         // DEBUG: notify if we are forcing unconfigured output
357         if ($permitted == 'forced' && !$userisconfigured) {
358             debugging('Attempt to force message delivery to user who has "'.$processor->name.'" output unconfigured', DEBUG_NORMAL);
359         }
361         // Populate the list of processors we will be using
362         if ($permitted == 'forced' && $userisconfigured) {
363             // An admin is forcing users to use this message processor. Use this processor unconditionally.
364             $processorlist[] = $processor->name;
365         } else if ($permitted == 'permitted' && $userisconfigured && !$eventdata->userto->emailstop) {
366             // User has not disabled notifications
367             // See if user set any notification preferences, otherwise use site default ones
368             $userpreferencename = 'message_provider_'.$preferencebase.'_'.$userstate;
369             if ($userpreference = get_user_preferences($userpreferencename, null, $eventdata->userto)) {
370                 if (in_array($processor->name, explode(',', $userpreference))) {
371                     $processorlist[] = $processor->name;
372                 }
373             } else if (isset($defaultpreferences->{$userpreferencename})) {
374                 if (in_array($processor->name, explode(',', $defaultpreferences->{$userpreferencename}))) {
375                     $processorlist[] = $processor->name;
376                 }
377             }
378         }
379     }
381     // Store unread message just in case we get a fatal error any time later.
382     $tabledata->id = $DB->insert_record($table, $tabledata);
383     $eventdata->savedmessageid = $tabledata->id;
385     // Let the manager do the sending or buffering when db transaction in progress.
386     return \core\message\manager::send_message($eventdata, $tabledata, $processorlist);
389 /**
390  * Updates the message_providers table with the current set of message providers
391  *
392  * @param string $component For example 'moodle', 'mod_forum' or 'block_quiz_results'
393  * @return boolean True on success
394  */
395 function message_update_providers($component='moodle') {
396     global $DB;
398     // load message providers from files
399     $fileproviders = message_get_providers_from_file($component);
401     // load message providers from the database
402     $dbproviders = message_get_providers_from_db($component);
404     foreach ($fileproviders as $messagename => $fileprovider) {
406         if (!empty($dbproviders[$messagename])) {   // Already exists in the database
407             // check if capability has changed
408             if ($dbproviders[$messagename]->capability == $fileprovider['capability']) {  // Same, so ignore
409                 // exact same message provider already present in db, ignore this entry
410                 unset($dbproviders[$messagename]);
411                 continue;
413             } else {                                // Update existing one
414                 $provider = new stdClass();
415                 $provider->id         = $dbproviders[$messagename]->id;
416                 $provider->capability = $fileprovider['capability'];
417                 $DB->update_record('message_providers', $provider);
418                 unset($dbproviders[$messagename]);
419                 continue;
420             }
422         } else {             // New message provider, add it
424             $provider = new stdClass();
425             $provider->name       = $messagename;
426             $provider->component  = $component;
427             $provider->capability = $fileprovider['capability'];
429             $transaction = $DB->start_delegated_transaction();
430             $DB->insert_record('message_providers', $provider);
431             message_set_default_message_preference($component, $messagename, $fileprovider);
432             $transaction->allow_commit();
433         }
434     }
436     foreach ($dbproviders as $dbprovider) {  // Delete old ones
437         $DB->delete_records('message_providers', array('id' => $dbprovider->id));
438         $DB->delete_records_select('config_plugins', "plugin = 'message' AND ".$DB->sql_like('name', '?', false), array("%_provider_{$component}_{$dbprovider->name}_%"));
439         $DB->delete_records_select('user_preferences', $DB->sql_like('name', '?', false), array("message_provider_{$component}_{$dbprovider->name}_%"));
440         cache_helper::invalidate_by_definition('core', 'config', array(), 'message');
441     }
443     return true;
446 /**
447  * This function populates default message preferences for all existing providers
448  * when the new message processor is added.
449  *
450  * @param string $processorname The name of message processor plugin (e.g. 'email', 'jabber')
451  * @throws invalid_parameter_exception if $processorname does not exist in the database
452  */
453 function message_update_processors($processorname) {
454     global $DB;
456     // validate if our processor exists
457     $processor = $DB->get_records('message_processors', array('name' => $processorname));
458     if (empty($processor)) {
459         throw new invalid_parameter_exception();
460     }
462     $providers = $DB->get_records_sql('SELECT DISTINCT component FROM {message_providers}');
464     $transaction = $DB->start_delegated_transaction();
465     foreach ($providers as $provider) {
466         // load message providers from files
467         $fileproviders = message_get_providers_from_file($provider->component);
468         foreach ($fileproviders as $messagename => $fileprovider) {
469             message_set_default_message_preference($provider->component, $messagename, $fileprovider, $processorname);
470         }
471     }
472     $transaction->allow_commit();
475 /**
476  * Setting default messaging preferences for particular message provider
477  *
478  * @param  string $component   The name of component (e.g. moodle, mod_forum, etc.)
479  * @param  string $messagename The name of message provider
480  * @param  array  $fileprovider The value of $messagename key in the array defined in plugin messages.php
481  * @param  string $processorname The optional name of message processor
482  */
483 function message_set_default_message_preference($component, $messagename, $fileprovider, $processorname='') {
484     global $DB;
486     // Fetch message processors
487     $condition = null;
488     // If we need to process a particular processor, set the select condition
489     if (!empty($processorname)) {
490        $condition = array('name' => $processorname);
491     }
492     $processors = $DB->get_records('message_processors', $condition);
494     // load default messaging preferences
495     $defaultpreferences = get_message_output_default_preferences();
497     // Setting default preference
498     $componentproviderbase = $component.'_'.$messagename;
499     $loggedinpref = array();
500     $loggedoffpref = array();
501     // set 'permitted' preference first for each messaging processor
502     foreach ($processors as $processor) {
503         $preferencename = $processor->name.'_provider_'.$componentproviderbase.'_permitted';
504         // if we do not have this setting yet, set it
505         if (!isset($defaultpreferences->{$preferencename})) {
506             // determine plugin default settings
507             $plugindefault = 0;
508             if (isset($fileprovider['defaults'][$processor->name])) {
509                 $plugindefault = $fileprovider['defaults'][$processor->name];
510             }
511             // get string values of the settings
512             list($permitted, $loggedin, $loggedoff) = translate_message_default_setting($plugindefault, $processor->name);
513             // store default preferences for current processor
514             set_config($preferencename, $permitted, 'message');
515             // save loggedin/loggedoff settings
516             if ($loggedin) {
517                 $loggedinpref[] = $processor->name;
518             }
519             if ($loggedoff) {
520                 $loggedoffpref[] = $processor->name;
521             }
522         }
523     }
524     // now set loggedin/loggedoff preferences
525     if (!empty($loggedinpref)) {
526         $preferencename = 'message_provider_'.$componentproviderbase.'_loggedin';
527         if (isset($defaultpreferences->{$preferencename})) {
528             // We have the default preferences for this message provider, which
529             // likely means that we have been adding a new processor. Add defaults
530             // to exisitng preferences.
531             $loggedinpref = array_merge($loggedinpref, explode(',', $defaultpreferences->{$preferencename}));
532         }
533         set_config($preferencename, join(',', $loggedinpref), 'message');
534     }
535     if (!empty($loggedoffpref)) {
536         $preferencename = 'message_provider_'.$componentproviderbase.'_loggedoff';
537         if (isset($defaultpreferences->{$preferencename})) {
538             // We have the default preferences for this message provider, which
539             // likely means that we have been adding a new processor. Add defaults
540             // to exisitng preferences.
541             $loggedoffpref = array_merge($loggedoffpref, explode(',', $defaultpreferences->{$preferencename}));
542         }
543         set_config($preferencename, join(',', $loggedoffpref), 'message');
544     }
547 /**
548  * Returns the active providers for the user specified, based on capability
549  *
550  * @param int $userid id of user
551  * @return array An array of message providers
552  */
553 function message_get_providers_for_user($userid) {
554     global $DB, $CFG;
556     $providers = get_message_providers();
558     // Ensure user is not allowed to configure instantmessage if it is globally disabled.
559     if (!$CFG->messaging) {
560         foreach ($providers as $providerid => $provider) {
561             if ($provider->name == 'instantmessage') {
562                 unset($providers[$providerid]);
563                 break;
564             }
565         }
566     }
568     // If the component is an enrolment plugin, check it is enabled
569     foreach ($providers as $providerid => $provider) {
570         list($type, $name) = core_component::normalize_component($provider->component);
571         if ($type == 'enrol' && !enrol_is_enabled($name)) {
572             unset($providers[$providerid]);
573         }
574     }
576     // Now we need to check capabilities. We need to eliminate the providers
577     // where the user does not have the corresponding capability anywhere.
578     // Here we deal with the common simple case of the user having the
579     // capability in the system context. That handles $CFG->defaultuserroleid.
580     // For the remaining providers/capabilities, we need to do a more complex
581     // query involving all overrides everywhere.
582     $unsureproviders = array();
583     $unsurecapabilities = array();
584     $systemcontext = context_system::instance();
585     foreach ($providers as $providerid => $provider) {
586         if (empty($provider->capability) || has_capability($provider->capability, $systemcontext, $userid)) {
587             // The provider is relevant to this user.
588             continue;
589         }
591         $unsureproviders[$providerid] = $provider;
592         $unsurecapabilities[$provider->capability] = 1;
593         unset($providers[$providerid]);
594     }
596     if (empty($unsureproviders)) {
597         // More complex checks are not required.
598         return $providers;
599     }
601     // Now check the unsure capabilities.
602     list($capcondition, $params) = $DB->get_in_or_equal(
603             array_keys($unsurecapabilities), SQL_PARAMS_NAMED);
604     $params['userid'] = $userid;
606     $sql = "SELECT DISTINCT rc.capability, 1
608               FROM {role_assignments} ra
609               JOIN {context} actx ON actx.id = ra.contextid
610               JOIN {role_capabilities} rc ON rc.roleid = ra.roleid
611               JOIN {context} cctx ON cctx.id = rc.contextid
613              WHERE ra.userid = :userid
614                AND rc.capability $capcondition
615                AND rc.permission > 0
616                AND (".$DB->sql_concat('actx.path', "'/'")." LIKE ".$DB->sql_concat('cctx.path', "'/%'").
617                " OR ".$DB->sql_concat('cctx.path', "'/'")." LIKE ".$DB->sql_concat('actx.path', "'/%'").")";
619     if (!empty($CFG->defaultfrontpageroleid)) {
620         $frontpagecontext = context_course::instance(SITEID);
622         list($capcondition2, $params2) = $DB->get_in_or_equal(
623                 array_keys($unsurecapabilities), SQL_PARAMS_NAMED);
624         $params = array_merge($params, $params2);
625         $params['frontpageroleid'] = $CFG->defaultfrontpageroleid;
626         $params['frontpagepathpattern'] = $frontpagecontext->path . '/';
628         $sql .= "
629              UNION
631             SELECT DISTINCT rc.capability, 1
633               FROM {role_capabilities} rc
634               JOIN {context} cctx ON cctx.id = rc.contextid
636              WHERE rc.roleid = :frontpageroleid
637                AND rc.capability $capcondition2
638                AND rc.permission > 0
639                AND ".$DB->sql_concat('cctx.path', "'/'")." LIKE :frontpagepathpattern";
640     }
642     $relevantcapabilities = $DB->get_records_sql_menu($sql, $params);
644     // Add back any providers based on the detailed capability check.
645     foreach ($unsureproviders as $providerid => $provider) {
646         if (array_key_exists($provider->capability, $relevantcapabilities)) {
647             $providers[$providerid] = $provider;
648         }
649     }
651     return $providers;
654 /**
655  * Gets the message providers that are in the database for this component.
656  *
657  * This is an internal function used within messagelib.php
658  *
659  * @see message_update_providers()
660  * @param string $component A moodle component like 'moodle', 'mod_forum', 'block_quiz_results'
661  * @return array An array of message providers
662  */
663 function message_get_providers_from_db($component) {
664     global $DB;
666     return $DB->get_records('message_providers', array('component'=>$component), '', 'name, id, component, capability');  // Name is unique per component
669 /**
670  * Loads the messages definitions for a component from file
671  *
672  * If no messages are defined for the component, return an empty array.
673  * This is an internal function used within messagelib.php
674  *
675  * @see message_update_providers()
676  * @see message_update_processors()
677  * @param string $component A moodle component like 'moodle', 'mod_forum', 'block_quiz_results'
678  * @return array An array of message providers or empty array if not exists
679  */
680 function message_get_providers_from_file($component) {
681     $defpath = core_component::get_component_directory($component).'/db/messages.php';
683     $messageproviders = array();
685     if (file_exists($defpath)) {
686         require($defpath);
687     }
689     foreach ($messageproviders as $name => $messageprovider) {   // Fix up missing values if required
690         if (empty($messageprovider['capability'])) {
691             $messageproviders[$name]['capability'] = NULL;
692         }
693         if (empty($messageprovider['defaults'])) {
694             $messageproviders[$name]['defaults'] = array();
695         }
696     }
698     return $messageproviders;
701 /**
702  * Remove all message providers for particular component and corresponding settings
703  *
704  * @param string $component A moodle component like 'moodle', 'mod_forum', 'block_quiz_results'
705  * @return void
706  */
707 function message_provider_uninstall($component) {
708     global $DB;
710     $transaction = $DB->start_delegated_transaction();
711     $DB->delete_records('message_providers', array('component' => $component));
712     $DB->delete_records_select('config_plugins', "plugin = 'message' AND ".$DB->sql_like('name', '?', false), array("%_provider_{$component}_%"));
713     $DB->delete_records_select('user_preferences', $DB->sql_like('name', '?', false), array("message_provider_{$component}_%"));
714     $transaction->allow_commit();
715     // Purge all messaging settings from the caches. They are stored by plugin so we have to clear all message settings.
716     cache_helper::invalidate_by_definition('core', 'config', array(), 'message');
719 /**
720  * Uninstall a message processor
721  *
722  * @param string $name A message processor name like 'email', 'jabber'
723  */
724 function message_processor_uninstall($name) {
725     global $DB;
727     $transaction = $DB->start_delegated_transaction();
728     $DB->delete_records('message_processors', array('name' => $name));
729     $DB->delete_records_select('config_plugins', "plugin = ?", array("message_{$name}"));
730     // delete permission preferences only, we do not care about loggedin/loggedoff
731     // defaults, they will be removed on the next attempt to update the preferences
732     $DB->delete_records_select('config_plugins', "plugin = 'message' AND ".$DB->sql_like('name', '?', false), array("{$name}_provider_%"));
733     $transaction->allow_commit();
734     // Purge all messaging settings from the caches. They are stored by plugin so we have to clear all message settings.
735     cache_helper::invalidate_by_definition('core', 'config', array(), array('message', "message_{$name}"));