mirror of
https://github.com/moodle/moodle.git
synced 2025-01-29 19:50:14 +01:00
5be5813ca1
When creating a course, a manual enrolment instance is added by default. The instance settings should inherit the values of those for the manual enrolment plugin and properly calculate its extra settings. The 'expirynotify' setting wasn't inherited correctly in case it had 'Enroller + Enrolled' value. A functional test was added to test the behaviour of settings inheritance.
669 lines
25 KiB
PHP
669 lines
25 KiB
PHP
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* Manual enrolment plugin main library file.
|
|
*
|
|
* @package enrol_manual
|
|
* @copyright 2010 Petr Skoda {@link http://skodak.org}
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
class enrol_manual_plugin extends enrol_plugin {
|
|
|
|
protected $lasternoller = null;
|
|
protected $lasternollerinstanceid = 0;
|
|
|
|
public function roles_protected() {
|
|
// Users may tweak the roles later.
|
|
return false;
|
|
}
|
|
|
|
public function allow_enrol(stdClass $instance) {
|
|
// Users with enrol cap may unenrol other users manually manually.
|
|
return true;
|
|
}
|
|
|
|
public function allow_unenrol(stdClass $instance) {
|
|
// Users with unenrol cap may unenrol other users manually manually.
|
|
return true;
|
|
}
|
|
|
|
public function allow_manage(stdClass $instance) {
|
|
// Users with manage cap may tweak period and status.
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns link to manual enrol UI if exists.
|
|
* Does the access control tests automatically.
|
|
*
|
|
* @param stdClass $instance
|
|
* @return moodle_url
|
|
*/
|
|
public function get_manual_enrol_link($instance) {
|
|
$name = $this->get_name();
|
|
if ($instance->enrol !== $name) {
|
|
throw new coding_exception('invalid enrol instance!');
|
|
}
|
|
|
|
if (!enrol_is_enabled($name)) {
|
|
return NULL;
|
|
}
|
|
|
|
$context = context_course::instance($instance->courseid, MUST_EXIST);
|
|
|
|
if (!has_capability('enrol/manual:enrol', $context)) {
|
|
// Note: manage capability not used here because it is used for editing
|
|
// of existing enrolments which is not possible here.
|
|
return NULL;
|
|
}
|
|
|
|
return new moodle_url('/enrol/manual/manage.php', array('enrolid'=>$instance->id, 'id'=>$instance->courseid));
|
|
}
|
|
|
|
/**
|
|
* Return true if we can add a new instance to this course.
|
|
*
|
|
* @param int $courseid
|
|
* @return boolean
|
|
*/
|
|
public function can_add_instance($courseid) {
|
|
global $DB;
|
|
|
|
$context = context_course::instance($courseid, MUST_EXIST);
|
|
if (!has_capability('moodle/course:enrolconfig', $context) or !has_capability('enrol/manual:config', $context)) {
|
|
return false;
|
|
}
|
|
|
|
if ($DB->record_exists('enrol', array('courseid'=>$courseid, 'enrol'=>'manual'))) {
|
|
// Multiple instances not supported.
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns edit icons for the page with list of instances.
|
|
* @param stdClass $instance
|
|
* @return array
|
|
*/
|
|
public function get_action_icons(stdClass $instance) {
|
|
global $OUTPUT;
|
|
|
|
$context = context_course::instance($instance->courseid);
|
|
|
|
$icons = array();
|
|
if (has_capability('enrol/manual:enrol', $context) or has_capability('enrol/manual:unenrol', $context)) {
|
|
$managelink = new moodle_url("/enrol/manual/manage.php", array('enrolid'=>$instance->id));
|
|
$icons[] = $OUTPUT->action_icon($managelink, new pix_icon('t/enrolusers', get_string('enrolusers', 'enrol_manual'), 'core', array('class'=>'iconsmall')));
|
|
}
|
|
$parenticons = parent::get_action_icons($instance);
|
|
$icons = array_merge($icons, $parenticons);
|
|
|
|
return $icons;
|
|
}
|
|
|
|
/**
|
|
* Add new instance of enrol plugin with default settings.
|
|
* @param stdClass $course
|
|
* @return int id of new instance, null if can not be created
|
|
*/
|
|
public function add_default_instance($course) {
|
|
$expirynotify = $this->get_config('expirynotify', 0);
|
|
|
|
$fields = array(
|
|
'status' => $this->get_config('status'),
|
|
'roleid' => $this->get_config('roleid', 0),
|
|
'enrolperiod' => $this->get_config('enrolperiod', 0),
|
|
'expirynotify' => $expirynotify,
|
|
'notifyall' => $expirynotify == 2 ? 1 : 0,
|
|
'expirythreshold' => $this->get_config('expirythreshold', 86400),
|
|
);
|
|
return $this->add_instance($course, $fields);
|
|
}
|
|
|
|
/**
|
|
* Add new instance of enrol plugin.
|
|
* @param stdClass $course
|
|
* @param array instance fields
|
|
* @return int id of new instance, null if can not be created
|
|
*/
|
|
public function add_instance($course, array $fields = NULL) {
|
|
global $DB;
|
|
|
|
if ($DB->record_exists('enrol', array('courseid'=>$course->id, 'enrol'=>'manual'))) {
|
|
// only one instance allowed, sorry
|
|
return NULL;
|
|
}
|
|
|
|
return parent::add_instance($course, $fields);
|
|
}
|
|
|
|
/**
|
|
* Update instance of enrol plugin.
|
|
* @param stdClass $instance
|
|
* @param stdClass $data modified instance fields
|
|
* @return boolean
|
|
*/
|
|
public function update_instance($instance, $data) {
|
|
global $DB;
|
|
|
|
// Delete all other instances, leaving only one.
|
|
if ($instances = $DB->get_records('enrol', array('courseid' => $instance->courseid, 'enrol' => 'manual'), 'id ASC')) {
|
|
foreach ($instances as $anotherinstance) {
|
|
if ($anotherinstance->id != $instance->id) {
|
|
$this->delete_instance($anotherinstance);
|
|
}
|
|
}
|
|
}
|
|
return parent::update_instance($instance, $data);
|
|
}
|
|
|
|
/**
|
|
* Returns a button to manually enrol users through the manual enrolment plugin.
|
|
*
|
|
* By default the first manual enrolment plugin instance available in the course is used.
|
|
* If no manual enrolment instances exist within the course then false is returned.
|
|
*
|
|
* This function also adds a quickenrolment JS ui to the page so that users can be enrolled
|
|
* via AJAX.
|
|
*
|
|
* @param course_enrolment_manager $manager
|
|
* @return enrol_user_button
|
|
*/
|
|
public function get_manual_enrol_button(course_enrolment_manager $manager) {
|
|
global $CFG, $PAGE;
|
|
require_once($CFG->dirroot.'/cohort/lib.php');
|
|
|
|
static $called = false;
|
|
|
|
$instance = null;
|
|
foreach ($manager->get_enrolment_instances() as $tempinstance) {
|
|
if ($tempinstance->enrol == 'manual') {
|
|
if ($instance === null) {
|
|
$instance = $tempinstance;
|
|
}
|
|
}
|
|
}
|
|
if (empty($instance)) {
|
|
return false;
|
|
}
|
|
|
|
$link = $this->get_manual_enrol_link($instance);
|
|
if (!$link) {
|
|
return false;
|
|
}
|
|
|
|
$button = new enrol_user_button($link, get_string('enrolusers', 'enrol_manual'), 'get');
|
|
$button->class .= ' enrol_manual_plugin';
|
|
$button->type = single_button::BUTTON_PRIMARY;
|
|
|
|
$context = context_course::instance($instance->courseid);
|
|
$arguments = array('contextid' => $context->id);
|
|
|
|
if (!$called) {
|
|
$called = true;
|
|
// Calling the following more than once will cause unexpected results.
|
|
$PAGE->requires->js_call_amd('enrol_manual/quickenrolment', 'init', array($arguments));
|
|
}
|
|
|
|
return $button;
|
|
}
|
|
|
|
/**
|
|
* Sync all meta course links.
|
|
*
|
|
* @param progress_trace $trace
|
|
* @param int $courseid one course, empty mean all
|
|
* @return int 0 means ok, 1 means error, 2 means plugin disabled
|
|
*/
|
|
public function sync(progress_trace $trace, $courseid = null) {
|
|
global $DB;
|
|
|
|
if (!enrol_is_enabled('manual')) {
|
|
$trace->finished();
|
|
return 2;
|
|
}
|
|
|
|
// Unfortunately this may take a long time, execution can be interrupted safely here.
|
|
core_php_time_limit::raise();
|
|
raise_memory_limit(MEMORY_HUGE);
|
|
|
|
$trace->output('Verifying manual enrolment expiration...');
|
|
|
|
$params = array('now'=>time(), 'useractive'=>ENROL_USER_ACTIVE, 'courselevel'=>CONTEXT_COURSE);
|
|
$coursesql = "";
|
|
if ($courseid) {
|
|
$coursesql = "AND e.courseid = :courseid";
|
|
$params['courseid'] = $courseid;
|
|
}
|
|
|
|
// Deal with expired accounts.
|
|
$action = $this->get_config('expiredaction', ENROL_EXT_REMOVED_KEEP);
|
|
|
|
if ($action == ENROL_EXT_REMOVED_UNENROL) {
|
|
$instances = array();
|
|
$sql = "SELECT ue.*, e.courseid, c.id AS contextid
|
|
FROM {user_enrolments} ue
|
|
JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = 'manual')
|
|
JOIN {context} c ON (c.instanceid = e.courseid AND c.contextlevel = :courselevel)
|
|
WHERE ue.timeend > 0 AND ue.timeend < :now
|
|
$coursesql";
|
|
$rs = $DB->get_recordset_sql($sql, $params);
|
|
foreach ($rs as $ue) {
|
|
if (empty($instances[$ue->enrolid])) {
|
|
$instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
|
|
}
|
|
$instance = $instances[$ue->enrolid];
|
|
// Always remove all manually assigned roles here, this may break enrol_self roles but we do not want hardcoded hacks here.
|
|
role_unassign_all(array('userid'=>$ue->userid, 'contextid'=>$ue->contextid, 'component'=>'', 'itemid'=>0), true);
|
|
$this->unenrol_user($instance, $ue->userid);
|
|
$trace->output("unenrolling expired user $ue->userid from course $instance->courseid", 1);
|
|
}
|
|
$rs->close();
|
|
unset($instances);
|
|
|
|
} else if ($action == ENROL_EXT_REMOVED_SUSPENDNOROLES or $action == ENROL_EXT_REMOVED_SUSPEND) {
|
|
$instances = array();
|
|
$sql = "SELECT ue.*, e.courseid, c.id AS contextid
|
|
FROM {user_enrolments} ue
|
|
JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = 'manual')
|
|
JOIN {context} c ON (c.instanceid = e.courseid AND c.contextlevel = :courselevel)
|
|
WHERE ue.timeend > 0 AND ue.timeend < :now
|
|
AND ue.status = :useractive
|
|
$coursesql";
|
|
$rs = $DB->get_recordset_sql($sql, $params);
|
|
foreach ($rs as $ue) {
|
|
if (empty($instances[$ue->enrolid])) {
|
|
$instances[$ue->enrolid] = $DB->get_record('enrol', array('id'=>$ue->enrolid));
|
|
}
|
|
$instance = $instances[$ue->enrolid];
|
|
if ($action == ENROL_EXT_REMOVED_SUSPENDNOROLES) {
|
|
// Remove all manually assigned roles here, this may break enrol_self roles but we do not want hardcoded hacks here.
|
|
role_unassign_all(array('userid'=>$ue->userid, 'contextid'=>$ue->contextid, 'component'=>'', 'itemid'=>0), true);
|
|
$this->update_user_enrol($instance, $ue->userid, ENROL_USER_SUSPENDED);
|
|
$trace->output("suspending expired user $ue->userid in course $instance->courseid, roles unassigned", 1);
|
|
} else {
|
|
$this->update_user_enrol($instance, $ue->userid, ENROL_USER_SUSPENDED);
|
|
$trace->output("suspending expired user $ue->userid in course $instance->courseid, roles kept", 1);
|
|
}
|
|
}
|
|
$rs->close();
|
|
unset($instances);
|
|
|
|
} else {
|
|
// ENROL_EXT_REMOVED_KEEP means no changes.
|
|
}
|
|
|
|
$trace->output('...manual enrolment updates finished.');
|
|
$trace->finished();
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Returns the user who is responsible for manual enrolments in given instance.
|
|
*
|
|
* Usually it is the first editing teacher - the person with "highest authority"
|
|
* as defined by sort_by_roleassignment_authority() having 'enrol/manual:manage'
|
|
* capability.
|
|
*
|
|
* @param int $instanceid enrolment instance id
|
|
* @return stdClass user record
|
|
*/
|
|
protected function get_enroller($instanceid) {
|
|
global $DB;
|
|
|
|
if ($this->lasternollerinstanceid == $instanceid and $this->lasternoller) {
|
|
return $this->lasternoller;
|
|
}
|
|
|
|
$instance = $DB->get_record('enrol', array('id'=>$instanceid, 'enrol'=>$this->get_name()), '*', MUST_EXIST);
|
|
$context = context_course::instance($instance->courseid);
|
|
|
|
if ($users = get_enrolled_users($context, 'enrol/manual:manage')) {
|
|
$users = sort_by_roleassignment_authority($users, $context);
|
|
$this->lasternoller = reset($users);
|
|
unset($users);
|
|
} else {
|
|
$this->lasternoller = parent::get_enroller($instanceid);
|
|
}
|
|
|
|
$this->lasternollerinstanceid = $instanceid;
|
|
|
|
return $this->lasternoller;
|
|
}
|
|
|
|
/**
|
|
* The manual plugin has several bulk operations that can be performed.
|
|
* @param course_enrolment_manager $manager
|
|
* @return array
|
|
*/
|
|
public function get_bulk_operations(course_enrolment_manager $manager) {
|
|
global $CFG;
|
|
require_once($CFG->dirroot.'/enrol/manual/locallib.php');
|
|
$context = $manager->get_context();
|
|
$bulkoperations = array();
|
|
if (has_capability("enrol/manual:manage", $context)) {
|
|
$bulkoperations['editselectedusers'] = new enrol_manual_editselectedusers_operation($manager, $this);
|
|
}
|
|
if (has_capability("enrol/manual:unenrol", $context)) {
|
|
$bulkoperations['deleteselectedusers'] = new enrol_manual_deleteselectedusers_operation($manager, $this);
|
|
}
|
|
return $bulkoperations;
|
|
}
|
|
|
|
/**
|
|
* Restore instance and map settings.
|
|
*
|
|
* @param restore_enrolments_structure_step $step
|
|
* @param stdClass $data
|
|
* @param stdClass $course
|
|
* @param int $oldid
|
|
*/
|
|
public function restore_instance(restore_enrolments_structure_step $step, stdClass $data, $course, $oldid) {
|
|
global $DB;
|
|
// There is only I manual enrol instance allowed per course.
|
|
if ($instances = $DB->get_records('enrol', array('courseid'=>$data->courseid, 'enrol'=>'manual'), 'id')) {
|
|
$instance = reset($instances);
|
|
$instanceid = $instance->id;
|
|
} else {
|
|
$instanceid = $this->add_instance($course, (array)$data);
|
|
}
|
|
$step->set_mapping('enrol', $oldid, $instanceid);
|
|
}
|
|
|
|
/**
|
|
* Restore user enrolment.
|
|
*
|
|
* @param restore_enrolments_structure_step $step
|
|
* @param stdClass $data
|
|
* @param stdClass $instance
|
|
* @param int $oldinstancestatus
|
|
* @param int $userid
|
|
*/
|
|
public function restore_user_enrolment(restore_enrolments_structure_step $step, $data, $instance, $userid, $oldinstancestatus) {
|
|
global $DB;
|
|
|
|
// Note: this is a bit tricky because other types may be converted to manual enrolments,
|
|
// and manual is restricted to one enrolment per user.
|
|
|
|
$ue = $DB->get_record('user_enrolments', array('enrolid'=>$instance->id, 'userid'=>$userid));
|
|
$enrol = false;
|
|
if ($ue and $ue->status == ENROL_USER_ACTIVE) {
|
|
// We do not want to restrict current active enrolments, let's kind of merge the times only.
|
|
// This prevents some teacher lockouts too.
|
|
if ($data->status == ENROL_USER_ACTIVE) {
|
|
if ($data->timestart > $ue->timestart) {
|
|
$data->timestart = $ue->timestart;
|
|
$enrol = true;
|
|
}
|
|
|
|
if ($data->timeend == 0) {
|
|
if ($ue->timeend != 0) {
|
|
$enrol = true;
|
|
}
|
|
} else if ($ue->timeend == 0) {
|
|
$data->timeend = 0;
|
|
} else if ($data->timeend < $ue->timeend) {
|
|
$data->timeend = $ue->timeend;
|
|
$enrol = true;
|
|
}
|
|
}
|
|
} else {
|
|
if ($instance->status == ENROL_INSTANCE_ENABLED and $oldinstancestatus != ENROL_INSTANCE_ENABLED) {
|
|
// Make sure that user enrolments are not activated accidentally,
|
|
// we do it only here because it is not expected that enrolments are migrated to other plugins.
|
|
$data->status = ENROL_USER_SUSPENDED;
|
|
}
|
|
$enrol = true;
|
|
}
|
|
|
|
if ($enrol) {
|
|
$this->enrol_user($instance, $userid, null, $data->timestart, $data->timeend, $data->status);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Restore role assignment.
|
|
*
|
|
* @param stdClass $instance
|
|
* @param int $roleid
|
|
* @param int $userid
|
|
* @param int $contextid
|
|
*/
|
|
public function restore_role_assignment($instance, $roleid, $userid, $contextid) {
|
|
// This is necessary only because we may migrate other types to this instance,
|
|
// we do not use component in manual or self enrol.
|
|
role_assign($roleid, $userid, $contextid, '', 0);
|
|
}
|
|
|
|
/**
|
|
* Restore user group membership.
|
|
* @param stdClass $instance
|
|
* @param int $groupid
|
|
* @param int $userid
|
|
*/
|
|
public function restore_group_member($instance, $groupid, $userid) {
|
|
global $CFG;
|
|
require_once("$CFG->dirroot/group/lib.php");
|
|
|
|
// This might be called when forcing restore as manual enrolments.
|
|
|
|
groups_add_member($groupid, $userid);
|
|
}
|
|
|
|
/**
|
|
* Is it possible to delete enrol instance via standard UI?
|
|
*
|
|
* @param object $instance
|
|
* @return bool
|
|
*/
|
|
public function can_delete_instance($instance) {
|
|
$context = context_course::instance($instance->courseid);
|
|
return has_capability('enrol/manual:config', $context);
|
|
}
|
|
|
|
/**
|
|
* Is it possible to hide/show enrol instance via standard UI?
|
|
*
|
|
* @param stdClass $instance
|
|
* @return bool
|
|
*/
|
|
public function can_hide_show_instance($instance) {
|
|
$context = context_course::instance($instance->courseid);
|
|
return has_capability('enrol/manual:config', $context);
|
|
}
|
|
|
|
/**
|
|
* Enrol all not enrolled cohort members into course via enrol instance.
|
|
*
|
|
* @param stdClass $instance
|
|
* @param int $cohortid
|
|
* @param int $roleid optional role id
|
|
* @param int $timestart 0 means unknown
|
|
* @param int $timeend 0 means forever
|
|
* @param int $status default to ENROL_USER_ACTIVE for new enrolments, no change by default in updates
|
|
* @param bool $recovergrades restore grade history
|
|
* @return int The number of enrolled cohort users
|
|
*/
|
|
public function enrol_cohort(stdClass $instance, $cohortid, $roleid = null, $timestart = 0, $timeend = 0, $status = null, $recovergrades = null) {
|
|
global $DB;
|
|
$context = context_course::instance($instance->courseid);
|
|
list($esql, $params) = get_enrolled_sql($context);
|
|
$sql = "SELECT cm.userid FROM {cohort_members} cm LEFT JOIN ($esql) u ON u.id = cm.userid ".
|
|
"WHERE cm.cohortid = :cohortid AND u.id IS NULL";
|
|
$params['cohortid'] = $cohortid;
|
|
$members = $DB->get_fieldset_sql($sql, $params);
|
|
foreach ($members as $userid) {
|
|
$this->enrol_user($instance, $userid, $roleid, $timestart, $timeend, $status, $recovergrades);
|
|
}
|
|
return count($members);
|
|
}
|
|
|
|
/**
|
|
* We are a good plugin and don't invent our own UI/validation code path.
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function use_standard_editing_ui() {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Return an array of valid options for the status.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function get_status_options() {
|
|
$options = array(ENROL_INSTANCE_ENABLED => get_string('yes'),
|
|
ENROL_INSTANCE_DISABLED => get_string('no'));
|
|
return $options;
|
|
}
|
|
|
|
/**
|
|
* Return an array of valid options for the roleid.
|
|
*
|
|
* @param stdClass $instance
|
|
* @param context $context
|
|
* @return array
|
|
*/
|
|
protected function get_roleid_options($instance, $context) {
|
|
if ($instance->id) {
|
|
$roles = get_default_enrol_roles($context, $instance->roleid);
|
|
} else {
|
|
$roles = get_default_enrol_roles($context, $this->get_config('roleid'));
|
|
}
|
|
return $roles;
|
|
}
|
|
|
|
/**
|
|
* Return an array of valid options for the expirynotify.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function get_expirynotify_options() {
|
|
$options = array(
|
|
0 => get_string('no'),
|
|
1 => get_string('expirynotifyenroller', 'core_enrol'),
|
|
2 => get_string('expirynotifyall', 'core_enrol')
|
|
);
|
|
return $options;
|
|
}
|
|
|
|
/**
|
|
* Add elements to the edit instance form.
|
|
*
|
|
* @param stdClass $instance
|
|
* @param MoodleQuickForm $mform
|
|
* @param context $context
|
|
* @return bool
|
|
*/
|
|
public function edit_instance_form($instance, MoodleQuickForm $mform, $context) {
|
|
|
|
$options = $this->get_status_options();
|
|
$mform->addElement('select', 'status', get_string('status', 'enrol_manual'), $options);
|
|
$mform->addHelpButton('status', 'status', 'enrol_manual');
|
|
$mform->setDefault('status', $this->get_config('status'));
|
|
|
|
$roles = $this->get_roleid_options($instance, $context);
|
|
$mform->addElement('select', 'roleid', get_string('defaultrole', 'role'), $roles);
|
|
$mform->setDefault('roleid', $this->get_config('roleid'));
|
|
|
|
$options = array('optional' => true, 'defaultunit' => 86400);
|
|
$mform->addElement('duration', 'enrolperiod', get_string('defaultperiod', 'enrol_manual'), $options);
|
|
$mform->setDefault('enrolperiod', $this->get_config('enrolperiod'));
|
|
$mform->addHelpButton('enrolperiod', 'defaultperiod', 'enrol_manual');
|
|
|
|
$options = $this->get_expirynotify_options();
|
|
$mform->addElement('select', 'expirynotify', get_string('expirynotify', 'core_enrol'), $options);
|
|
$mform->addHelpButton('expirynotify', 'expirynotify', 'core_enrol');
|
|
|
|
$options = array('optional' => false, 'defaultunit' => 86400);
|
|
$mform->addElement('duration', 'expirythreshold', get_string('expirythreshold', 'core_enrol'), $options);
|
|
$mform->addHelpButton('expirythreshold', 'expirythreshold', 'core_enrol');
|
|
$mform->disabledIf('expirythreshold', 'expirynotify', 'eq', 0);
|
|
|
|
if (enrol_accessing_via_instance($instance)) {
|
|
$warntext = get_string('instanceeditselfwarningtext', 'core_enrol');
|
|
$mform->addElement('static', 'selfwarn', get_string('instanceeditselfwarning', 'core_enrol'), $warntext);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Perform custom validation of the data used to edit the instance.
|
|
*
|
|
* @param array $data array of ("fieldname"=>value) of submitted data
|
|
* @param array $files array of uploaded files "element_name"=>tmp_file_path
|
|
* @param object $instance The instance loaded from the DB
|
|
* @param context $context The context of the instance we are editing
|
|
* @return array of "element_name"=>"error_description" if there are errors,
|
|
* or an empty array if everything is OK.
|
|
* @return void
|
|
*/
|
|
public function edit_instance_validation($data, $files, $instance, $context) {
|
|
$errors = array();
|
|
|
|
if ($data['expirynotify'] > 0 and $data['expirythreshold'] < 86400) {
|
|
$errors['expirythreshold'] = get_string('errorthresholdlow', 'core_enrol');
|
|
}
|
|
|
|
$validstatus = array_keys($this->get_status_options());
|
|
$validroles = array_keys($this->get_roleid_options($instance, $context));
|
|
$validexpirynotify = array_keys($this->get_expirynotify_options());
|
|
|
|
$tovalidate = array(
|
|
'status' => $validstatus,
|
|
'roleid' => $validroles,
|
|
'enrolperiod' => PARAM_INT,
|
|
'expirynotify' => $validexpirynotify,
|
|
'expirythreshold' => PARAM_INT
|
|
);
|
|
|
|
$typeerrors = $this->validate_param_types($data, $tovalidate);
|
|
$errors = array_merge($errors, $typeerrors);
|
|
|
|
return $errors;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Serve the manual enrol users form as a fragment.
|
|
*
|
|
* @param array $args List of named arguments for the fragment loader.
|
|
* @return string
|
|
*/
|
|
function enrol_manual_output_fragment_enrol_users_form($args) {
|
|
$args = (object) $args;
|
|
$context = $args->context;
|
|
$o = '';
|
|
|
|
require_capability('enrol/manual:enrol', $context);
|
|
$mform = new enrol_manual_enrol_users_form(null, $args);
|
|
|
|
ob_start();
|
|
$mform->display();
|
|
$o .= ob_get_contents();
|
|
ob_end_clean();
|
|
|
|
return $o;
|
|
}
|