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/>.
  16
  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  */
  24
  25 defined('MOODLE_INTERNAL') || die();
  26
  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 {
  38
  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()));
  51
  52         // Add message output processors enabled/disabled and settings.
  53         $output .= $this->heading(get_string('messageoutputs', 'message'));
  54         $output .= $this->manage_messageoutputs($allprocessors);
  55
  56         // Add active message output processors settings.
  57         $output .= $this->heading(get_string('managemessageoutputs', 'message'));
  58         $output .= $this->manage_defaultmessageoutputs($processors, $providers, $preferences);
  59
  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');
  66
  67         return $output;
  68     }
  69
  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         );
  89
  90         foreach ($processors as $processor) {
  91             $row = new html_table_row();
  92             $row->attributes['class'] = 'messageoutputs';
  93
  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             }
 111
 112             $row->cells = array($name, $enable, $settings);
 113             $table->data[] = $row;
 114         }
 115         return html_writer::table($table);
 116     }
 117
 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         }
 132
 133         // Display users outputs table
 134         $table = new html_table();
 135         $table->attributes['class'] = 'generaltable';
 136         $table->data        = array();
 137         $table->head        = array('');
 138
 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');
 145
 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();
 151
 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         }
 215
 216         $output = html_writer::table($table);
 217         return $output;
 218     }
 219
 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);
 229
 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     }
 236
 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;
 245
 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         });
 254
 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);
 262
 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;
 285
 286         return $this->render_from_template('message/message_preferences', $context);
 287     }
 288 }