enrol/guest/lib.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  * Guest access plugin.
  19  *
  20  * This plugin does not add any entries into the user_enrolments table,
  21  * the access control is granted on the fly via the tricks in require_login().
  22  *
  23  * @package    enrol_guest
  24  * @copyright  2010 Petr Skoda  {@link http://skodak.org}
  25  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  26  */
  27
  28 defined('MOODLE_INTERNAL') || die();
  29
  30 /**
  31  * Class enrol_guest_plugin
  32  *
  33  * @copyright  2010 Petr Skoda  {@link http://skodak.org}
  34  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  35  */
  36 class enrol_guest_plugin extends enrol_plugin {
  37
  38     /**
  39      * Returns optional enrolment information icons.
  40      *
  41      * This is used in course list for quick overview of enrolment options.
  42      *
  43      * We are not using single instance parameter because sometimes
  44      * we might want to prevent icon repetition when multiple instances
  45      * of one type exist. One instance may also produce several icons.
  46      *
  47      * @param array $instances all enrol instances of this type in one course
  48      * @return array of pix_icon
  49      */
  50     public function get_info_icons(array $instances) {
  51         foreach ($instances as $instance) {
  52             if ($instance->password !== '') {
  53                 return array(new pix_icon('withpassword', get_string('guestaccess_withpassword', 'enrol_guest'), 'enrol_guest'));
  54             } else {
  55                 return array(new pix_icon('withoutpassword', get_string('guestaccess_withoutpassword', 'enrol_guest'), 'enrol_guest'));
  56             }
  57         }
  58     }
  59
  60     /**
  61      * Enrol a user using a given enrolment instance.
  62      *
  63      * @param stdClass $instance
  64      * @param int $userid
  65      * @param null $roleid
  66      * @param int $timestart
  67      * @param int $timeend
  68      * @param null $status
  69      * @param null $recovergrades
  70      */
  71     public function enrol_user(stdClass $instance, $userid, $roleid = null, $timestart = 0, $timeend = 0, $status = null, $recovergrades = null) {
  72         // no real enrolments here!
  73         return;
  74     }
  75
  76     /**
  77      * Enrol a user from a given enrolment instance.
  78      *
  79      * @param stdClass $instance
  80      * @param int $userid
  81      */
  82     public function unenrol_user(stdClass $instance, $userid) {
  83         // nothing to do, we never enrol here!
  84         return;
  85     }
  86
  87     /**
  88      * Attempt to automatically gain temporary guest access to course,
  89      * calling code has to make sure the plugin and instance are active.
  90      *
  91      * @param stdClass $instance course enrol instance
  92      * @return bool|int false means no guest access, integer means end of cached time
  93      */
  94     public function try_guestaccess(stdClass $instance) {
  95         global $USER, $CFG;
  96
  97         $allow = false;
  98
  99         if ($instance->password === '') {
 100             $allow = true;
 101
 102         } else if (isset($USER->enrol_guest_passwords[$instance->id])) { // this is a hack, ideally we should not add stuff to $USER...
 103             if ($USER->enrol_guest_passwords[$instance->id] === $instance->password) {
 104                 $allow = true;
 105             }
 106         }
 107
 108         if ($allow) {
 109             // Temporarily assign them some guest role for this context
 110             $context = context_course::instance($instance->courseid);
 111             load_temp_course_role($context, $CFG->guestroleid);
 112             return ENROL_MAX_TIMESTAMP;
 113         }
 114
 115         return false;
 116     }
 117
 118     /**
 119      * Returns true if the current user can add a new instance of enrolment plugin in course.
 120      * @param int $courseid
 121      * @return boolean
 122      */
 123     public function can_add_instance($courseid) {
 124         global $DB;
 125
 126         $context = context_course::instance($courseid, MUST_EXIST);
 127
 128         if (!has_capability('moodle/course:enrolconfig', $context) or !has_capability('enrol/guest:config', $context)) {
 129             return false;
 130         }
 131
 132         if ($DB->record_exists('enrol', array('courseid'=>$courseid, 'enrol'=>'guest'))) {
 133             return false;
 134         }
 135
 136         return true;
 137     }
 138
 139     /**
 140      * Creates course enrol form, checks if form submitted
 141      * and enrols user if necessary. It can also redirect.
 142      *
 143      * @param stdClass $instance
 144      * @return string html text, usually a form in a text box
 145      */
 146     public function enrol_page_hook(stdClass $instance) {
 147         global $CFG, $OUTPUT, $SESSION, $USER;
 148
 149         if ($instance->password === '') {
 150             return null;
 151         }
 152
 153         if (isset($USER->enrol['tempguest'][$instance->courseid]) and $USER->enrol['tempguest'][$instance->courseid] > time()) {
 154             // no need to show the guest access when user can already enter course as guest
 155             return null;
 156         }
 157
 158         require_once("$CFG->dirroot/enrol/guest/locallib.php");
 159         $form = new enrol_guest_enrol_form(NULL, $instance);
 160         $instanceid = optional_param('instance', 0, PARAM_INT);
 161
 162         if ($instance->id == $instanceid) {
 163             if ($data = $form->get_data()) {
 164                 // add guest role
 165                 $context = context_course::instance($instance->courseid);
 166                 $USER->enrol_guest_passwords[$instance->id] = $data->guestpassword; // this is a hack, ideally we should not add stuff to $USER...
 167                 if (isset($USER->enrol['tempguest'][$instance->courseid])) {
 168                     remove_temp_course_roles($context);
 169                 }
 170                 load_temp_course_role($context, $CFG->guestroleid);
 171                 $USER->enrol['tempguest'][$instance->courseid] = ENROL_MAX_TIMESTAMP;
 172
 173                 // go to the originally requested page
 174                 if (!empty($SESSION->wantsurl)) {
 175                     $destination = $SESSION->wantsurl;
 176                     unset($SESSION->wantsurl);
 177                 } else {
 178                     $destination = "$CFG->wwwroot/course/view.php?id=$instance->courseid";
 179                 }
 180                 redirect($destination);
 181             }
 182         }
 183
 184         ob_start();
 185         $form->display();
 186         $output = ob_get_clean();
 187
 188         return $OUTPUT->box($output, 'generalbox');
 189     }
 190
 191     /**
 192      * Called after updating/inserting course.
 193      *
 194      * @param bool $inserted true if course just inserted
 195      * @param object $course
 196      * @param object $data form data
 197      * @return void
 198      */
 199     public function course_updated($inserted, $course, $data) {
 200         global $DB;
 201
 202         if ($inserted) {
 203             if (isset($data->enrol_guest_status_0)) {
 204                 $fields = array('status'=>$data->enrol_guest_status_0);
 205                 if ($fields['status'] == ENROL_INSTANCE_ENABLED) {
 206                     $fields['password'] = $data->enrol_guest_password_0;
 207                 } else {
 208                     if ($this->get_config('requirepassword')) {
 209                         $fields['password'] = generate_password(20);
 210                     }
 211                 }
 212                 $this->add_instance($course, $fields);
 213             } else {
 214                 if ($this->get_config('defaultenrol')) {
 215                     $this->add_default_instance($course);
 216                 }
 217             }
 218
 219         } else {
 220             $instances = $DB->get_records('enrol', array('courseid'=>$course->id, 'enrol'=>'guest'));
 221             foreach ($instances as $instance) {
 222                 $i = $instance->id;
 223
 224                 if (isset($data->{'enrol_guest_status_'.$i})) {
 225                     $reset = ($instance->status != $data->{'enrol_guest_status_'.$i});
 226
 227                     $instance->status       = $data->{'enrol_guest_status_'.$i};
 228                     $instance->timemodified = time();
 229                     if ($instance->status == ENROL_INSTANCE_ENABLED) {
 230                         if ($instance->password !== $data->{'enrol_guest_password_'.$i}) {
 231                             $reset = true;
 232                         }
 233                         $instance->password = $data->{'enrol_guest_password_'.$i};
 234                     }
 235                     $DB->update_record('enrol', $instance);
 236                     \core\event\enrol_instance_updated::create_from_record($instance)->trigger();
 237
 238                     if ($reset) {
 239                         $context = context_course::instance($course->id);
 240                         $context->mark_dirty();
 241                     }
 242                 }
 243             }
 244         }
 245     }
 246
 247     /**
 248      * Add new instance of enrol plugin.
 249      * @param object $course
 250      * @param array instance fields
 251      * @return int id of new instance, null if can not be created
 252      */
 253     public function add_instance($course, array $fields = NULL) {
 254         $fields = (array)$fields;
 255
 256         if (!isset($fields['password'])) {
 257             $fields['password'] = '';
 258         }
 259
 260         return parent::add_instance($course, $fields);
 261     }
 262
 263     /**
 264      * Add new instance of enrol plugin with default settings.
 265      * @param object $course
 266      * @return int id of new instance
 267      */
 268     public function add_default_instance($course) {
 269         $fields = array('status'=>$this->get_config('status'));
 270
 271         if ($this->get_config('requirepassword')) {
 272             $fields['password'] = generate_password(20);
 273         }
 274
 275         return $this->add_instance($course, $fields);
 276     }
 277
 278     /**
 279      * Restore instance and map settings.
 280      *
 281      * @param restore_enrolments_structure_step $step
 282      * @param stdClass $data
 283      * @param stdClass $course
 284      * @param int $oldid
 285      */
 286     public function restore_instance(restore_enrolments_structure_step $step, stdClass $data, $course, $oldid) {
 287         global $DB;
 288
 289         if (!$DB->record_exists('enrol', array('courseid' => $data->courseid, 'enrol' => $this->get_name()))) {
 290             $this->add_instance($course, (array)$data);
 291         }
 292
 293         // No need to set mapping, we do not restore users or roles here.
 294         $step->set_mapping('enrol', $oldid, 0);
 295     }
 296
 297     /**
 298      * Is it possible to delete enrol instance via standard UI?
 299      *
 300      * @param object $instance
 301      * @return bool
 302      */
 303     public function can_delete_instance($instance) {
 304         $context = context_course::instance($instance->courseid);
 305         return has_capability('enrol/guest:config', $context);
 306     }
 307
 308     /**
 309      * Is it possible to hide/show enrol instance via standard UI?
 310      *
 311      * @param stdClass $instance
 312      * @return bool
 313      */
 314     public function can_hide_show_instance($instance) {
 315         $context = context_course::instance($instance->courseid);
 316         if (!has_capability('enrol/guest:config', $context)) {
 317             return false;
 318         }
 319
 320         // If the instance is currently disabled, before it can be enabled, we must check whether the password meets the
 321         // password policies.
 322         if ($instance->status == ENROL_INSTANCE_DISABLED) {
 323             if ($this->get_config('requirepassword')) {
 324                 if (empty($instance->password)) {
 325                     return false;
 326                 }
 327             }
 328
 329             // Only check the password if it is set.
 330             if (!empty($instance->password) && $this->get_config('usepasswordpolicy')) {
 331                 if (!check_password_policy($instance->password, $errmsg)) {
 332                     return false;
 333                 }
 334             }
 335         }
 336
 337         return true;
 338     }
 339
 340     /**
 341      * Get default settings for enrol_guest.
 342      *
 343      * @return array
 344      */
 345     public function get_instance_defaults() {
 346         $fields = array();
 347         $fields['status']          = $this->get_config('status');
 348         return $fields;
 349     }
 350
 351     /**
 352      * Return information for enrolment instance containing list of parameters required
 353      * for enrolment, name of enrolment plugin etc.
 354      *
 355      * @param stdClass $instance enrolment instance
 356      * @return stdClass instance info.
 357      * @since Moodle 3.1
 358      */
 359     public function get_enrol_info(stdClass $instance) {
 360
 361         $instanceinfo = new stdClass();
 362         $instanceinfo->id = $instance->id;
 363         $instanceinfo->courseid = $instance->courseid;
 364         $instanceinfo->type = $this->get_name();
 365         $instanceinfo->name = $this->get_instance_name($instance);
 366         $instanceinfo->status = $instance->status == ENROL_INSTANCE_ENABLED;
 367
 368         // Specifics enrolment method parameters.
 369         $instanceinfo->requiredparam = new stdClass();
 370         $instanceinfo->requiredparam->passwordrequired = !empty($instance->password);
 371
 372         // If the plugin is enabled, return the URL for obtaining more information.
 373         if ($instanceinfo->status) {
 374             $instanceinfo->wsfunction = 'enrol_guest_get_instance_info';
 375         }
 376         return $instanceinfo;
 377     }
 378
 379     /**
 380      * Return an array of valid options for the status.
 381      *
 382      * @return array
 383      */
 384     protected function get_status_options() {
 385         $options = array(ENROL_INSTANCE_ENABLED  => get_string('yes'),
 386                          ENROL_INSTANCE_DISABLED => get_string('no'));
 387         return $options;
 388     }
 389
 390     /**
 391      * Add elements to the edit instance form.
 392      *
 393      * @param stdClass $instance
 394      * @param MoodleQuickForm $mform
 395      * @param context $context
 396      * @return bool
 397      */
 398     public function edit_instance_form($instance, MoodleQuickForm $mform, $context) {
 399         global $CFG;
 400
 401         $options = $this->get_status_options();
 402         $mform->addElement('select', 'status', get_string('status', 'enrol_guest'), $options);
 403         $mform->addHelpButton('status', 'status', 'enrol_guest');
 404         $mform->setDefault('status', $this->get_config('status'));
 405         $mform->setAdvanced('status', $this->get_config('status_adv'));
 406
 407         $mform->addElement('passwordunmask', 'password', get_string('password', 'enrol_guest'));
 408         $mform->addHelpButton('password', 'password', 'enrol_guest');
 409
 410         // If we have a new instance and the password is required - make sure it is set. For existing
 411         // instances we do not force the password to be required as it may have been set to empty before
 412         // the password was required. We check in the validation function whether this check is required
 413         // for existing instances.
 414         if (empty($instance->id) && $this->get_config('requirepassword')) {
 415             $mform->addRule('password', get_string('required'), 'required', null);
 416         }
 417     }
 418
 419     /**
 420      * We are a good plugin and don't invent our own UI/validation code path.
 421      *
 422      * @return boolean
 423      */
 424     public function use_standard_editing_ui() {
 425         return true;
 426     }
 427
 428     /**
 429      * Perform custom validation of the data used to edit the instance.
 430      *
 431      * @param array $data array of ("fieldname"=>value) of submitted data
 432      * @param array $files array of uploaded files "element_name"=>tmp_file_path
 433      * @param object $instance The instance loaded from the DB
 434      * @param context $context The context of the instance we are editing
 435      * @return array of "element_name"=>"error_description" if there are errors,
 436      *         or an empty array if everything is OK.
 437      * @return void
 438      */
 439     public function edit_instance_validation($data, $files, $instance, $context) {
 440         $errors = array();
 441
 442         $checkpassword = false;
 443
 444         if ($data['id']) {
 445             // Check the password if we are enabling the plugin again.
 446             if (($instance->status == ENROL_INSTANCE_DISABLED) && ($data['status'] == ENROL_INSTANCE_ENABLED)) {
 447                 $checkpassword = true;
 448             }
 449
 450             // Check the password if the instance is enabled and the password has changed.
 451             if (($data['status'] == ENROL_INSTANCE_ENABLED) && ($instance->password !== $data['password'])) {
 452                 $checkpassword = true;
 453             }
 454         } else {
 455             $checkpassword = true;
 456         }
 457
 458         if ($checkpassword) {
 459             $require = $this->get_config('requirepassword');
 460             $policy  = $this->get_config('usepasswordpolicy');
 461             if ($require && trim($data['password']) === '') {
 462                 $errors['password'] = get_string('required');
 463             } else if (!empty($data['password']) && $policy) {
 464                 $errmsg = '';
 465                 if (!check_password_policy($data['password'], $errmsg)) {
 466                     $errors['password'] = $errmsg;
 467                 }
 468             }
 469         }
 470
 471         $validstatus = array_keys($this->get_status_options());
 472         $tovalidate = array(
 473             'status' => $validstatus
 474         );
 475         $typeerrors = $this->validate_param_types($data, $tovalidate);
 476         $errors = array_merge($errors, $typeerrors);
 477
 478         return $errors;
 479     }
 480
 481
 482 }
 483
 484 /**
 485  * Get icon mapping for font-awesome.
 486  */
 487 function enrol_guest_get_fontawesome_icon_map() {
 488     return [
 489         'enrol_guest:withpassword' => 'fa-key',
 490         'enrol_guest:withoutpassword' => 'fa-unlock-alt',
 491     ];
 492 }