enrol/manual/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  * Manual enrolment plugin main library file.
  19  *
  20  * @package    enrol_manual
  21  * @copyright  2010 Petr Skoda {@link http://skodak.org}
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 defined('MOODLE_INTERNAL') || die();
  26
  27 class enrol_manual_plugin extends enrol_plugin {
  28
  29     protected $lasternoller = null;
  30     protected $lasternollerinstanceid = 0;
  31
  32     public function roles_protected() {
  33         // Users may tweak the roles later.
  34         return false;
  35     }
  36
  37     public function allow_enrol(stdClass $instance) {
  38         // Users with enrol cap may unenrol other users manually manually.
  39         return true;
  40     }
  41
  42     public function allow_unenrol(stdClass $instance) {
  43         // Users with unenrol cap may unenrol other users manually manually.
  44         return true;
  45     }
  46
  47     public function allow_manage(stdClass $instance) {
  48         // Users with manage cap may tweak period and status.
  49         return true;
  50     }
  51
  52     /**
  53      * Returns link to manual enrol UI if exists.
  54      * Does the access control tests automatically.
  55      *
  56      * @param stdClass $instance
  57      * @return moodle_url
  58      */
  59     public function get_manual_enrol_link($instance) {
  60         $name = $this->get_name();
  61         if ($instance->enrol !== $name) {
  62             throw new coding_exception('invalid enrol instance!');
  63         }
  64
  65         if (!enrol_is_enabled($name)) {
  66             return NULL;
  67         }
  68
  69         $context = context_course::instance($instance->courseid, MUST_EXIST);
  70
  71         if (!has_capability('enrol/manual:enrol', $context)) {
  72             // Note: manage capability not used here because it is used for editing
  73             // of existing enrolments which is not possible here.
  74             return NULL;
  75         }
  76
  77         return new moodle_url('/enrol/manual/manage.php', array('enrolid'=>$instance->id, 'id'=>$instance->courseid));
  78     }
  79
  80     /**
  81      * Return true if we can add a new instance to this course.
  82      *
  83      * @param int $courseid
  84      * @return boolean
  85      */
  86     public function can_add_instance($courseid) {
  87         global $DB;
  88
  89         $context = context_course::instance($courseid, MUST_EXIST);
  90         if (!has_capability('moodle/course:enrolconfig', $context) or !has_capability('enrol/manual:config', $context)) {
  91             return false;
  92         }
  93
  94         if ($DB->record_exists('enrol', array('courseid'=>$courseid, 'enrol'=>'manual'))) {
  95             // Multiple instances not supported.
  96             return false;
  97         }
  98
  99         return true;
 100     }
 101
 102     /**
 103      * Returns edit icons for the page with list of instances.
 104      * @param stdClass $instance
 105      * @return array
 106      */
 107     public function get_action_icons(stdClass $instance) {
 108         global $OUTPUT;
 109
 110         $context = context_course::instance($instance->courseid);
 111
 112         $icons = array();
 113         if (has_capability('enrol/manual:enrol', $context) or has_capability('enrol/manual:unenrol', $context)) {
 114             $managelink = new moodle_url("/enrol/manual/manage.php", array('enrolid'=>$instance->id));
 115             $icons[] = $OUTPUT->action_icon($managelink, new pix_icon('t/enrolusers', get_string('enrolusers', 'enrol_manual'), 'core', array('class'=>'iconsmall')));
 116         }
 117         $parenticons = parent::get_action_icons($instance);
 118         $icons = array_merge($icons, $parenticons);
 119
 120         return $icons;
 121     }
 122
 123     /**
 124      * Add new instance of enrol plugin with default settings.
 125      * @param stdClass $course
 126      * @return int id of new instance, null if can not be created
 127      */
 128     public function add_default_instance($course) {
 129         $expirynotify = $this->get_config('expirynotify', 0);
 130         if ($expirynotify == 2) {
 131             $expirynotify = 1;
 132             $notifyall = 1;
 133         } else {
 134             $notifyall = 0;
 135         }
 136         $fields = array(
 137             'status'          => $this->get_config('status'),
 138             'roleid'          => $this->get_config('roleid', 0),
 139             'enrolperiod'     => $this->get_config('enrolperiod', 0),
 140             'expirynotify'    => $expirynotify,
 141             'notifyall'       => $notifyall,
 142             'expirythreshold' => $this->get_config('expirythreshold', 86400),
 143         );
 144         return $this->add_instance($course, $fields);
 145     }
 146
 147     /**
 148      * Add new instance of enrol plugin.
 149      * @param stdClass $course
 150      * @param array instance fields
 151      * @return int id of new instance, null if can not be created
 152      */
 153     public function add_instance($course, array $fields = NULL) {
 154         global $DB;
 155
 156         if ($DB->record_exists('enrol', array('courseid'=>$course->id, 'enrol'=>'manual'))) {
 157             // only one instance allowed, sorry
 158             return NULL;
 159         }
 160
 161         return parent::add_instance($course, $fields);
 162     }
 163
 164     /**
 165      * Update instance of enrol plugin.
 166      * @param stdClass $instance
 167      * @param stdClass $data modified instance fields
 168      * @return boolean
 169      */
 170     public function update_instance($instance, $data) {
 171         global $DB;
 172
 173         // Delete all other instances, leaving only one.
 174         if ($instances = $DB->get_records('enrol', array('courseid' => $instance->courseid, 'enrol' => 'manual'), 'id ASC')) {
 175             foreach ($instances as $anotherinstance) {
 176                 if ($anotherinstance->id != $instance->id) {
 177                     $this->delete_instance($anotherinstance);
 178                 }
 179             }
 180         }
 181         return parent::update_instance($instance, $data);
 182     }
 183
 184     /**
 185      * Returns a button to manually enrol users through the manual enrolment plugin.
 186      *
 187      * By default the first manual enrolment plugin instance available in the course is used.
 188      * If no manual enrolment instances exist within the course then false is returned.
 189      *
 190      * This function also adds a quickenrolment JS ui to the page so that users can be enrolled
 191      * via AJAX.
 192      *
 193      * @param course_enrolment_manager $manager
 194      * @return enrol_user_button
 195      */
 196     public function get_manual_enrol_button(course_enrolment_manager $manager) {
 197         global $CFG, $PAGE;
 198         require_once($CFG->dirroot.'/cohort/lib.php');
 199
 200         $instance = null;
 201         $instances = array();
 202         foreach ($manager->get_enrolment_instances() as $tempinstance) {
 203             if ($tempinstance->enrol == 'manual') {
 204                 if ($instance === null) {
 205                     $instance = $tempinstance;
 206                 }
 207                 $instances[] = array('id' => $tempinstance->id, 'name' => $this->get_instance_name($tempinstance));
 208             }
 209         }
 210         if (empty($instance)) {
 211             return false;
 212         }
 213
 214         $link = $this->get_manual_enrol_link($instance);
 215         if (!$link) {
 216             return false;
 217         }
 218
 219         $button = new enrol_user_button($link, get_string('enrolusers', 'enrol_manual'), 'get');
 220         $button->class .= ' enrol_manual_plugin';
 221
 222         $context = context_course::instance($instance->courseid);
 223         $arguments = array('contextid' => $context->id);
 224
 225         $PAGE->requires->js_call_amd('enrol_manual/quickenrolment', 'init', array($arguments));
 226
 227         return $button;
 228     }
 229
 230     /**
 231      * Enrol cron support.
 232      * @return void
 233      */
 234     public function cron() {
 235         $trace = new text_progress_trace();
 236         $this->sync($trace, null);
 237         $this->send_expiry_notifications($trace);
 238     }
 239
 240     /**
 241      * Sync all meta course links.
 242      *
 243      * @param progress_trace $trace
 244      * @param int $courseid one course, empty mean all
 245      * @return int 0 means ok, 1 means error, 2 means plugin disabled
 246      */
 247     public function sync(progress_trace $trace, $courseid = null) {
 248         global $DB;
 249
 250         if (!enrol_is_enabled('manual')) {
 251             $trace->finished();
 252             return 2;
 253         }
 254
 255         // Unfortunately this may take a long time, execution can be interrupted safely here.
 256         core_php_time_limit::raise();
 257         raise_memory_limit(MEMORY_HUGE);
 258
 259         $trace->output('Verifying manual enrolment expiration...');
 260
 261         $params = array('now'=>time(), 'useractive'=>ENROL_USER_ACTIVE, 'courselevel'=>CONTEXT_COURSE);
 262         $coursesql = "";
 263         if ($courseid) {
 264             $coursesql = "AND e.courseid = :courseid";
 265             $params['courseid'] = $courseid;
 266         }
 267
 268         // Deal with expired accounts.
 269         $action = $this->get_config('expiredaction', ENROL_EXT_REMOVED_KEEP);
 270
 271         if ($action == ENROL_EXT_REMOVED_UNENROL) {
 272             $instances = array();
 273             $sql = "SELECT ue.*, e.courseid, c.id AS contextid
 274                       FROM {user_enrolments} ue
 275                       JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = 'manual')
 276                       JOIN {context} c ON (c.instanceid = e.courseid AND c.contextlevel = :courselevel)
 277                      WHERE ue.timeend > 0 AND ue.timeend < :now
 278                            $coursesql";
 279             $rs = $DB->get_recordset_sql($sql, $params);
 280             foreach ($rs as $ue) {
 281                 if (empty($instances[$ue->enrolid])) {
 282                     $instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
 283                 }
 284                 $instance = $instances[$ue->enrolid];
 285                 // Always remove all manually assigned roles here, this may break enrol_self roles but we do not want hardcoded hacks here.
 286                 role_unassign_all(array('userid'=>$ue->userid, 'contextid'=>$ue->contextid, 'component'=>'', 'itemid'=>0), true);
 287                 $this->unenrol_user($instance, $ue->userid);
 288                 $trace->output("unenrolling expired user $ue->userid from course $instance->courseid", 1);
 289             }
 290             $rs->close();
 291             unset($instances);
 292
 293         } else if ($action == ENROL_EXT_REMOVED_SUSPENDNOROLES or $action == ENROL_EXT_REMOVED_SUSPEND) {
 294             $instances = array();
 295             $sql = "SELECT ue.*, e.courseid, c.id AS contextid
 296                       FROM {user_enrolments} ue
 297                       JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = 'manual')
 298                       JOIN {context} c ON (c.instanceid = e.courseid AND c.contextlevel = :courselevel)
 299                      WHERE ue.timeend > 0 AND ue.timeend < :now
 300                            AND ue.status = :useractive
 301                            $coursesql";
 302             $rs = $DB->get_recordset_sql($sql, $params);
 303             foreach ($rs as $ue) {
 304                 if (empty($instances[$ue->enrolid])) {
 305                     $instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
 306                 }
 307                 $instance = $instances[$ue->enrolid];
 308                 if ($action == ENROL_EXT_REMOVED_SUSPENDNOROLES) {
 309                     // Remove all manually assigned roles here, this may break enrol_self roles but we do not want hardcoded hacks here.
 310                     role_unassign_all(array('userid'=>$ue->userid, 'contextid'=>$ue->contextid, 'component'=>'', 'itemid'=>0), true);
 311                     $this->update_user_enrol($instance, $ue->userid, ENROL_USER_SUSPENDED);
 312                     $trace->output("suspending expired user $ue->userid in course $instance->courseid, roles unassigned", 1);
 313                 } else {
 314                     $this->update_user_enrol($instance, $ue->userid, ENROL_USER_SUSPENDED);
 315                     $trace->output("suspending expired user $ue->userid in course $instance->courseid, roles kept", 1);
 316                 }
 317             }
 318             $rs->close();
 319             unset($instances);
 320
 321         } else {
 322             // ENROL_EXT_REMOVED_KEEP means no changes.
 323         }
 324
 325         $trace->output('...manual enrolment updates finished.');
 326         $trace->finished();
 327
 328         return 0;
 329     }
 330
 331     /**
 332      * Returns the user who is responsible for manual enrolments in given instance.
 333      *
 334      * Usually it is the first editing teacher - the person with "highest authority"
 335      * as defined by sort_by_roleassignment_authority() having 'enrol/manual:manage'
 336      * capability.
 337      *
 338      * @param int $instanceid enrolment instance id
 339      * @return stdClass user record
 340      */
 341     protected function get_enroller($instanceid) {
 342         global $DB;
 343
 344         if ($this->lasternollerinstanceid == $instanceid and $this->lasternoller) {
 345             return $this->lasternoller;
 346         }
 347
 348         $instance = $DB->get_record('enrol', array('id'=>$instanceid, 'enrol'=>$this->get_name()), '*', MUST_EXIST);
 349         $context = context_course::instance($instance->courseid);
 350
 351         if ($users = get_enrolled_users($context, 'enrol/manual:manage')) {
 352             $users = sort_by_roleassignment_authority($users, $context);
 353             $this->lasternoller = reset($users);
 354             unset($users);
 355         } else {
 356             $this->lasternoller = parent::get_enroller($instanceid);
 357         }
 358
 359         $this->lasternollerinstanceid = $instanceid;
 360
 361         return $this->lasternoller;
 362     }
 363
 364     /**
 365      * Gets an array of the user enrolment actions.
 366      *
 367      * @param course_enrolment_manager $manager
 368      * @param stdClass $ue A user enrolment object
 369      * @return array An array of user_enrolment_actions
 370      */
 371     public function get_user_enrolment_actions(course_enrolment_manager $manager, $ue) {
 372         $actions = array();
 373         $context = $manager->get_context();
 374         $instance = $ue->enrolmentinstance;
 375         $params = $manager->get_moodlepage()->url->params();
 376         $params['ue'] = $ue->id;
 377         if ($this->allow_unenrol_user($instance, $ue) && has_capability("enrol/manual:unenrol", $context)) {
 378             $url = new moodle_url('/enrol/unenroluser.php', $params);
 379             $actionparams = array('class' => 'unenrollink', 'rel' => $ue->id, 'data-action' => ENROL_ACTION_UNENROL);
 380             $actions[] = new user_enrolment_action(new pix_icon('t/delete', ''), get_string('unenrol', 'enrol'), $url,
 381                 $actionparams);
 382         }
 383         if ($this->allow_manage($instance) && has_capability("enrol/manual:manage", $context)) {
 384             $url = new moodle_url('/enrol/editenrolment.php', $params);
 385             $actionparams = array('class' => 'editenrollink', 'rel' => $ue->id, 'data-action' => ENROL_ACTION_EDIT);
 386             $actions[] = new user_enrolment_action(new pix_icon('t/edit', ''), get_string('edit'), $url, $actionparams);
 387         }
 388         return $actions;
 389     }
 390
 391     /**
 392      * The manual plugin has several bulk operations that can be performed.
 393      * @param course_enrolment_manager $manager
 394      * @return array
 395      */
 396     public function get_bulk_operations(course_enrolment_manager $manager) {
 397         global $CFG;
 398         require_once($CFG->dirroot.'/enrol/manual/locallib.php');
 399         $context = $manager->get_context();
 400         $bulkoperations = array();
 401         if (has_capability("enrol/manual:manage", $context)) {
 402             $bulkoperations['editselectedusers'] = new enrol_manual_editselectedusers_operation($manager, $this);
 403         }
 404         if (has_capability("enrol/manual:unenrol", $context)) {
 405             $bulkoperations['deleteselectedusers'] = new enrol_manual_deleteselectedusers_operation($manager, $this);
 406         }
 407         return $bulkoperations;
 408     }
 409
 410     /**
 411      * Restore instance and map settings.
 412      *
 413      * @param restore_enrolments_structure_step $step
 414      * @param stdClass $data
 415      * @param stdClass $course
 416      * @param int $oldid
 417      */
 418     public function restore_instance(restore_enrolments_structure_step $step, stdClass $data, $course, $oldid) {
 419         global $DB;
 420         // There is only I manual enrol instance allowed per course.
 421         if ($instances = $DB->get_records('enrol', array('courseid'=>$data->courseid, 'enrol'=>'manual'), 'id')) {
 422             $instance = reset($instances);
 423             $instanceid = $instance->id;
 424         } else {
 425             $instanceid = $this->add_instance($course, (array)$data);
 426         }
 427         $step->set_mapping('enrol', $oldid, $instanceid);
 428     }
 429
 430     /**
 431      * Restore user enrolment.
 432      *
 433      * @param restore_enrolments_structure_step $step
 434      * @param stdClass $data
 435      * @param stdClass $instance
 436      * @param int $oldinstancestatus
 437      * @param int $userid
 438      */
 439     public function restore_user_enrolment(restore_enrolments_structure_step $step, $data, $instance, $userid, $oldinstancestatus) {
 440         global $DB;
 441
 442         // Note: this is a bit tricky because other types may be converted to manual enrolments,
 443         //       and manual is restricted to one enrolment per user.
 444
 445         $ue = $DB->get_record('user_enrolments', array('enrolid'=>$instance->id, 'userid'=>$userid));
 446         $enrol = false;
 447         if ($ue and $ue->status == ENROL_USER_ACTIVE) {
 448             // We do not want to restrict current active enrolments, let's kind of merge the times only.
 449             // This prevents some teacher lockouts too.
 450             if ($data->status == ENROL_USER_ACTIVE) {
 451                 if ($data->timestart > $ue->timestart) {
 452                     $data->timestart = $ue->timestart;
 453                     $enrol = true;
 454                 }
 455
 456                 if ($data->timeend == 0) {
 457                     if ($ue->timeend != 0) {
 458                         $enrol = true;
 459                     }
 460                 } else if ($ue->timeend == 0) {
 461                     $data->timeend = 0;
 462                 } else if ($data->timeend < $ue->timeend) {
 463                     $data->timeend = $ue->timeend;
 464                     $enrol = true;
 465                 }
 466             }
 467         } else {
 468             if ($instance->status == ENROL_INSTANCE_ENABLED and $oldinstancestatus != ENROL_INSTANCE_ENABLED) {
 469                 // Make sure that user enrolments are not activated accidentally,
 470                 // we do it only here because it is not expected that enrolments are migrated to other plugins.
 471                 $data->status = ENROL_USER_SUSPENDED;
 472             }
 473             $enrol = true;
 474         }
 475
 476         if ($enrol) {
 477             $this->enrol_user($instance, $userid, null, $data->timestart, $data->timeend, $data->status);
 478         }
 479     }
 480
 481     /**
 482      * Restore role assignment.
 483      *
 484      * @param stdClass $instance
 485      * @param int $roleid
 486      * @param int $userid
 487      * @param int $contextid
 488      */
 489     public function restore_role_assignment($instance, $roleid, $userid, $contextid) {
 490         // This is necessary only because we may migrate other types to this instance,
 491         // we do not use component in manual or self enrol.
 492         role_assign($roleid, $userid, $contextid, '', 0);
 493     }
 494
 495     /**
 496      * Restore user group membership.
 497      * @param stdClass $instance
 498      * @param int $groupid
 499      * @param int $userid
 500      */
 501     public function restore_group_member($instance, $groupid, $userid) {
 502         global $CFG;
 503         require_once("$CFG->dirroot/group/lib.php");
 504
 505         // This might be called when forcing restore as manual enrolments.
 506
 507         groups_add_member($groupid, $userid);
 508     }
 509
 510     /**
 511      * Is it possible to delete enrol instance via standard UI?
 512      *
 513      * @param object $instance
 514      * @return bool
 515      */
 516     public function can_delete_instance($instance) {
 517         $context = context_course::instance($instance->courseid);
 518         return has_capability('enrol/manual:config', $context);
 519     }
 520
 521     /**
 522      * Is it possible to hide/show enrol instance via standard UI?
 523      *
 524      * @param stdClass $instance
 525      * @return bool
 526      */
 527     public function can_hide_show_instance($instance) {
 528         $context = context_course::instance($instance->courseid);
 529         return has_capability('enrol/manual:config', $context);
 530     }
 531
 532     /**
 533      * Enrol all not enrolled cohort members into course via enrol instance.
 534      *
 535      * @param stdClass $instance
 536      * @param int $cohortid
 537      * @param int $roleid optional role id
 538      * @param int $timestart 0 means unknown
 539      * @param int $timeend 0 means forever
 540      * @param int $status default to ENROL_USER_ACTIVE for new enrolments, no change by default in updates
 541      * @param bool $recovergrades restore grade history
 542      */
 543     public function enrol_cohort(stdClass $instance, $cohortid, $roleid = null, $timestart = 0, $timeend = 0, $status = null, $recovergrades = null) {
 544         global $DB;
 545         $context = context_course::instance($instance->courseid);
 546         list($esql, $params) = get_enrolled_sql($context);
 547         $sql = "SELECT cm.userid FROM {cohort_members} cm LEFT JOIN ($esql) u ON u.id = cm.userid ".
 548             "WHERE cm.cohortid = :cohortid AND u.id IS NULL";
 549         $params['cohortid'] = $cohortid;
 550         $members = $DB->get_fieldset_sql($sql, $params);
 551         foreach ($members as $userid) {
 552             $this->enrol_user($instance, $userid, $roleid, $timestart, $timeend, $status, $recovergrades);
 553         }
 554     }
 555
 556     /**
 557      * We are a good plugin and don't invent our own UI/validation code path.
 558      *
 559      * @return boolean
 560      */
 561     public function use_standard_editing_ui() {
 562         return true;
 563     }
 564
 565     /**
 566      * Return an array of valid options for the status.
 567      *
 568      * @return array
 569      */
 570     protected function get_status_options() {
 571         $options = array(ENROL_INSTANCE_ENABLED  => get_string('yes'),
 572                          ENROL_INSTANCE_DISABLED => get_string('no'));
 573         return $options;
 574     }
 575
 576     /**
 577      * Return an array of valid options for the roleid.
 578      *
 579      * @param stdClass $instance
 580      * @param context $context
 581      * @return array
 582      */
 583     protected function get_roleid_options($instance, $context) {
 584         if ($instance->id) {
 585             $roles = get_default_enrol_roles($context, $instance->roleid);
 586         } else {
 587             $roles = get_default_enrol_roles($context, $this->get_config('roleid'));
 588         }
 589         return $roles;
 590     }
 591
 592     /**
 593      * Return an array of valid options for the expirynotify.
 594      *
 595      * @return array
 596      */
 597     protected function get_expirynotify_options() {
 598         $options = array(
 599             0 => get_string('no'),
 600             1 => get_string('expirynotifyenroller', 'core_enrol'),
 601             2 => get_string('expirynotifyall', 'core_enrol')
 602         );
 603         return $options;
 604     }
 605
 606     /**
 607      * Add elements to the edit instance form.
 608      *
 609      * @param stdClass $instance
 610      * @param MoodleQuickForm $mform
 611      * @param context $context
 612      * @return bool
 613      */
 614     public function edit_instance_form($instance, MoodleQuickForm $mform, $context) {
 615
 616         $options = $this->get_status_options();
 617         $mform->addElement('select', 'status', get_string('status', 'enrol_manual'), $options);
 618         $mform->addHelpButton('status', 'status', 'enrol_manual');
 619         $mform->setDefault('status', $this->get_config('status'));
 620
 621         $roles = $this->get_roleid_options($instance, $context);
 622         $mform->addElement('select', 'roleid', get_string('defaultrole', 'role'), $roles);
 623         $mform->setDefault('roleid', $this->get_config('roleid'));
 624
 625         $options = array('optional' => true, 'defaultunit' => 86400);
 626         $mform->addElement('duration', 'enrolperiod', get_string('defaultperiod', 'enrol_manual'), $options);
 627         $mform->setDefault('enrolperiod', $this->get_config('enrolperiod'));
 628         $mform->addHelpButton('enrolperiod', 'defaultperiod', 'enrol_manual');
 629
 630         $options = $this->get_expirynotify_options();
 631         $mform->addElement('select', 'expirynotify', get_string('expirynotify', 'core_enrol'), $options);
 632         $mform->addHelpButton('expirynotify', 'expirynotify', 'core_enrol');
 633
 634         $options = array('optional' => false, 'defaultunit' => 86400);
 635         $mform->addElement('duration', 'expirythreshold', get_string('expirythreshold', 'core_enrol'), $options);
 636         $mform->addHelpButton('expirythreshold', 'expirythreshold', 'core_enrol');
 637         $mform->disabledIf('expirythreshold', 'expirynotify', 'eq', 0);
 638
 639         if (enrol_accessing_via_instance($instance)) {
 640             $warntext = get_string('instanceeditselfwarningtext', 'core_enrol');
 641             $mform->addElement('static', 'selfwarn', get_string('instanceeditselfwarning', 'core_enrol'), $warntext);
 642         }
 643     }
 644
 645     /**
 646      * Perform custom validation of the data used to edit the instance.
 647      *
 648      * @param array $data array of ("fieldname"=>value) of submitted data
 649      * @param array $files array of uploaded files "element_name"=>tmp_file_path
 650      * @param object $instance The instance loaded from the DB
 651      * @param context $context The context of the instance we are editing
 652      * @return array of "element_name"=>"error_description" if there are errors,
 653      *         or an empty array if everything is OK.
 654      * @return void
 655      */
 656     public function edit_instance_validation($data, $files, $instance, $context) {
 657         $errors = array();
 658
 659         if ($data['expirynotify'] > 0 and $data['expirythreshold'] < 86400) {
 660             $errors['expirythreshold'] = get_string('errorthresholdlow', 'core_enrol');
 661         }
 662
 663         $validstatus = array_keys($this->get_status_options());
 664         $validroles = array_keys($this->get_roleid_options($instance, $context));
 665         $validexpirynotify = array_keys($this->get_expirynotify_options());
 666
 667         $tovalidate = array(
 668             'status' => $validstatus,
 669             'roleid' => $validroles,
 670             'enrolperiod' => PARAM_INT,
 671             'expirynotify' => $validexpirynotify,
 672             'expirythreshold' => PARAM_INT
 673         );
 674
 675         $typeerrors = $this->validate_param_types($data, $tovalidate);
 676         $errors = array_merge($errors, $typeerrors);
 677
 678         return $errors;
 679     }
 680
 681 }
 682
 683 /**
 684  * Serve the manual enrol users form as a fragment.
 685  *
 686  * @param array $args List of named arguments for the fragment loader.
 687  * @return string
 688  */
 689 function enrol_manual_output_fragment_enrol_users_form($args) {
 690     $args = (object) $args;
 691     $context = $args->context;
 692     $o = '';
 693
 694     require_capability('enrol/manual:enrol', $context);
 695     $mform = new enrol_manual_enrol_users_form(null, $args);
 696
 697     ob_start();
 698     $mform->display();
 699     $o .= ob_get_contents();
 700     ob_end_clean();
 701
 702     return $o;
 703 }