weekly release 3.10.1+
[moodle.git] / message / renderer.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 renderer objects for messaging
19  *
20  * @package    core_message
21  * @copyright  2011 Lancaster University Network Services Limited
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 defined('MOODLE_INTERNAL') || die();
27 /**
28  * message Renderer
29  *
30  * Class for rendering various message objects
31  *
32  * @package    core_message
33  * @subpackage message
34  * @copyright  2011 Lancaster University Network Services Limited
35  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
36  */
37 class core_message_renderer extends plugin_renderer_base {
39     /**
40      * Display the interface to manage both message outputs and default message outputs
41      *
42      * @param  array $allprocessors  array of objects containing all message processors
43      * @param  array $processors  array of objects containing active message processors
44      * @param  array $providers   array of objects containing message providers
45      * @param  stdClass $preferences object containing current preferences
46      * @return string The text to render
47      */
48     public function manage_messageoutput_settings($allprocessors, $processors, $providers, $preferences) {
49         $output = html_writer::start_tag('form', array('id' => 'defaultmessageoutputs', 'method' => 'post'));
50         $output .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'sesskey', 'value' => sesskey()));
52         // Add message output processors enabled/disabled and settings.
53         $output .= $this->heading(get_string('messageoutputs', 'message'));
54         $output .= $this->manage_messageoutputs($allprocessors);
56         // Add active message output processors settings.
57         $output .= $this->heading(get_string('managemessageoutputs', 'message'));
58         $output .= $this->manage_defaultmessageoutputs($processors, $providers, $preferences);
60         $output .= html_writer::start_tag('div', array('class' => 'form-buttons'));
61         $output .= html_writer::empty_tag('input',
62             array('type' => 'submit', 'value' => get_string('savechanges', 'admin'), 'class' => 'form-submit btn btn-primary')
63         );
64         $output .= html_writer::end_tag('div');
65         $output .= html_writer::end_tag('form');
67         return $output;
68     }
70     /**
71      * Display the interface to manage message outputs
72      *
73      * @param  array  $processors array of objects containing message processors
74      * @return string The text to render
75      */
76     public function manage_messageoutputs($processors) {
77         // Display the current workflows
78         $table = new html_table();
79         $table->attributes['class'] = 'admintable generaltable';
80         $table->data        = array();
81         $table->head        = array(
82             get_string('name'),
83             get_string('enable'),
84             get_string('settings'),
85         );
86         $table->colclasses = array(
87             'displayname', 'availability', 'settings',
88         );
90         foreach ($processors as $processor) {
91             $row = new html_table_row();
92             $row->attributes['class'] = 'messageoutputs';
94             $name = new html_table_cell(get_string('pluginname', 'message_'.$processor->name));
95             $enable = new html_table_cell();
96             if (!$processor->available) {
97                 $enable->text = html_writer::nonempty_tag('span', get_string('outputnotavailable', 'message'),
98                     array('class' => 'error')
99                 );
100             } else {
101                 $enable->text = html_writer::checkbox($processor->name, $processor->id, $processor->enabled, '',
102                     array('id' => $processor->name)
103                 );
104             }
105             // Settings
106             $settings = new html_table_cell();
107             if ($processor->available && $processor->hassettings) {
108                 $settingsurl = new moodle_url('/admin/settings.php', array('section' => 'messagesetting'.$processor->name));
109                 $settings->text = html_writer::link($settingsurl, get_string('settings', 'message'));
110             }
112             $row->cells = array($name, $enable, $settings);
113             $table->data[] = $row;
114         }
115         return html_writer::table($table);
116     }
118     /**
119      * Display the interface to manage default message outputs
120      *
121      * @param  array $processors  array of objects containing message processors
122      * @param  array $providers   array of objects containing message providers
123      * @param  stdClass $preferences object containing current preferences
124      * @return string The text to render
125      */
126     public function manage_defaultmessageoutputs($processors, $providers, $preferences) {
127         // Prepare list of options for dropdown menu
128         $options = array();
129         foreach (array('disallowed', 'permitted', 'forced') as $setting) {
130             $options[$setting] = get_string($setting, 'message');
131         }
133         // Display users outputs table
134         $table = new html_table();
135         $table->attributes['class'] = 'generaltable';
136         $table->data        = array();
137         $table->head        = array('');
139         // Populate the header row
140         foreach ($processors as $processor) {
141             $table->head[]  = get_string('pluginname', 'message_'.$processor->name);
142         }
143         // Add enable/disable to head
144         $table->head[] = get_string('enabled', 'core_message');
146         // Generate the matrix of settings for each provider and processor
147         foreach ($providers as $provider) {
148             $row = new html_table_row();
149             $row->attributes['class'] = 'defaultmessageoutputs';
150             $row->cells = array();
152             // Provider Name
153             $providername = get_string('messageprovider:'.$provider->name, $provider->component);
154             $row->cells[] = new html_table_cell($providername);
155             $providersettingprefix = $provider->component.'_'.$provider->name.'_';
156             $disableprovidersetting = $providersettingprefix.'disable';
157             $providerdisabled = !empty($preferences->$disableprovidersetting);
158             // Settings for each processor
159             foreach ($processors as $processor) {
160                 $cellcontent = '';
161                 foreach (array('permitted', 'loggedin', 'loggedoff') as $setting) {
162                     // pepare element and preference names
163                     $elementname = $providersettingprefix.$setting.'['.$processor->name.']';
164                     $preferencebase = $providersettingprefix.$setting;
165                     // prepare language bits
166                     $processorname = get_string('pluginname', 'message_'.$processor->name);
167                     $statename = get_string($setting, 'message');
168                     $labelparams = array(
169                         'provider'  => $providername,
170                         'processor' => $processorname,
171                         'state'     => $statename
172                     );
173                     if ($setting == 'permitted') {
174                         $label = get_string('sendingvia', 'message', $labelparams);
175                         // determine the current setting or use default
176                         $select = MESSAGE_DEFAULT_PERMITTED;
177                         $preference = $processor->name.'_provider_'.$preferencebase;
178                         if ($providerdisabled) {
179                             $select = MESSAGE_DISALLOWED;
180                         } else if (property_exists($preferences, $preference)) {
181                             $select = $preferences->{$preference};
182                         }
183                         // dropdown menu
184                         $cellcontent = html_writer::label($label, $elementname, true, array('class' => 'accesshide'));
185                         $cellcontent .= html_writer::select($options, $elementname, $select, false, array('id' => $elementname));
186                         $cellcontent .= html_writer::tag('div', get_string('defaults', 'message'));
187                     } else {
188                         $label = get_string('sendingviawhen', 'message', $labelparams);
189                         // determine the current setting based on the 'permitted' setting above
190                         $checked = false;
191                         if ($select == 'forced') {
192                             $checked = true;
193                         } else if ($select == 'permitted') {
194                             $preference = 'message_provider_'.$preferencebase;
195                             if (property_exists($preferences, $preference)) {
196                                 $checked = (int)in_array($processor->name, explode(',', $preferences->{$preference}));
197                             }
198                         }
199                         // generate content
200                         $cellcontent .= html_writer::start_tag('div');
201                         $cellcontent .= html_writer::label($label, $elementname, true, array('class' => 'accesshide'));
202                         $cellcontent .= html_writer::checkbox($elementname, 1, $checked, '', array('id' => $elementname));
203                         $cellcontent .= $statename;
204                         $cellcontent .= html_writer::end_tag('div');
205                     }
206                 }
207                 $row->cells[] = new html_table_cell($cellcontent);
208             }
209             $disableprovider = html_writer::checkbox($disableprovidersetting, 1, !$providerdisabled, '',
210                     array('id' => $disableprovidersetting, 'class' => 'messagedisable'));
211             $disableprovider = html_writer::tag('div', $disableprovider);
212             $row->cells[] = new html_table_cell($disableprovider);
213             $table->data[] = $row;
214         }
216         $output = html_writer::table($table);
217         return $output;
218     }
220     /**
221      * Display the interface for notification preferences
222      *
223      * @param object $user instance of a user
224      * @return string The text to render
225      */
226     public function render_user_notification_preferences($user) {
227         $processors = get_message_processors();
228         $providers = message_get_providers_for_user($user->id);
230         $preferences = \core_message\api::get_all_message_preferences($processors, $providers, $user);
231         $notificationlistoutput = new \core_message\output\preferences\notification_list($processors, $providers,
232             $preferences, $user);
233         return $this->render_from_template('message/notification_preferences',
234             $notificationlistoutput->export_for_template($this));
235     }
237     /**
238      * Display the interface for message preferences
239      *
240      * @param object $user instance of a user
241      * @return string The text to render
242      */
243     public function render_user_message_preferences($user) {
244         global $CFG;
246         // Filter out enabled, available system_configured and user_configured processors only.
247         $readyprocessors = array_filter(get_message_processors(), function($processor) {
248             return $processor->enabled &&
249                 $processor->configured &&
250                 $processor->object->is_user_configured() &&
251                 // Filter out processors that don't have and message preferences to configure.
252                 $processor->object->has_message_preferences();
253         });
255         $providers = array_filter(message_get_providers_for_user($user->id), function($provider) {
256             return $provider->component === 'moodle';
257         });
258         $preferences = \core_message\api::get_all_message_preferences($readyprocessors, $providers, $user);
259         $notificationlistoutput = new \core_message\output\preferences\message_notification_list($readyprocessors,
260             $providers, $preferences, $user);
261         $context = $notificationlistoutput->export_for_template($this);
263         // Get the privacy settings options for being messaged.
264         $privacysetting = \core_message\api::get_user_privacy_messaging_preference($user->id);
265         $choices = array();
266         $choices[] = [
267             'value' => \core_message\api::MESSAGE_PRIVACY_ONLYCONTACTS,
268             'text' => get_string('contactableprivacy_onlycontacts', 'message'),
269             'checked' => ($privacysetting == \core_message\api::MESSAGE_PRIVACY_ONLYCONTACTS)
270         ];
271         $choices[] = [
272             'value' => \core_message\api::MESSAGE_PRIVACY_COURSEMEMBER,
273             'text' => get_string('contactableprivacy_coursemember', 'message'),
274             'checked' => ($privacysetting == \core_message\api::MESSAGE_PRIVACY_COURSEMEMBER)
275         ];
276         if (!empty($CFG->messagingallusers)) {
277             // Add the MESSAGE_PRIVACY_SITE option when site-wide messaging between users is enabled.
278             $choices[] = [
279                 'value' => \core_message\api::MESSAGE_PRIVACY_SITE,
280                 'text' => get_string('contactableprivacy_site', 'message'),
281                 'checked' => ($privacysetting == \core_message\api::MESSAGE_PRIVACY_SITE)
282             ];
283         }
284         $context['privacychoices'] = $choices;
286         return $this->render_from_template('message/message_preferences', $context);
287     }