mirror of
https://github.com/moodle/moodle.git
synced 2025-08-05 08:56:36 +02:00
757 lines
29 KiB
PHP
757 lines
29 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 $lasternollercourseid = 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:manage', $context) or !has_capability('enrol/manual:enrol', $context) or !has_capability('enrol/manual:unenrol', $context)) {
|
|
return NULL;
|
|
}
|
|
|
|
return new moodle_url('/enrol/manual/manage.php', array('enrolid'=>$instance->id, 'id'=>$instance->courseid));
|
|
}
|
|
|
|
/**
|
|
* Returns enrolment instance manage link.
|
|
*
|
|
* By defaults looks for manage.php file and tests for manage capability.
|
|
*
|
|
* @param navigation_node $instancesnode
|
|
* @param stdClass $instance
|
|
* @return moodle_url;
|
|
*/
|
|
public function add_course_navigation($instancesnode, stdClass $instance) {
|
|
if ($instance->enrol !== 'manual') {
|
|
throw new coding_exception('Invalid enrol instance type!');
|
|
}
|
|
|
|
$context = context_course::instance($instance->courseid);
|
|
if (has_capability('enrol/manual:config', $context)) {
|
|
$managelink = new moodle_url('/enrol/manual/edit.php', array('courseid'=>$instance->courseid));
|
|
$instancesnode->add($this->get_instance_name($instance), $managelink, navigation_node::TYPE_SETTING);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns edit icons for the page with list of instances.
|
|
* @param stdClass $instance
|
|
* @return array
|
|
*/
|
|
public function get_action_icons(stdClass $instance) {
|
|
global $OUTPUT;
|
|
|
|
if ($instance->enrol !== 'manual') {
|
|
throw new coding_exception('invalid enrol instance!');
|
|
}
|
|
$context = context_course::instance($instance->courseid);
|
|
|
|
$icons = array();
|
|
|
|
if (has_capability('enrol/manual:manage', $context)) {
|
|
$managelink = new moodle_url("/enrol/manual/manage.php", array('enrolid'=>$instance->id));
|
|
$icons[] = $OUTPUT->action_icon($managelink, new pix_icon('i/users', get_string('enrolusers', 'enrol_manual'), 'core', array('class'=>'iconsmall')));
|
|
}
|
|
if (has_capability('enrol/manual:config', $context)) {
|
|
$editlink = new moodle_url("/enrol/manual/edit.php", array('courseid'=>$instance->courseid));
|
|
$icons[] = $OUTPUT->action_icon($editlink, new pix_icon('i/edit', get_string('edit'), 'core', array('class'=>'icon')));
|
|
}
|
|
|
|
return $icons;
|
|
}
|
|
|
|
/**
|
|
* Returns link to page which may be used to add new instance of enrolment plugin in course.
|
|
* @param int $courseid
|
|
* @return moodle_url page url
|
|
*/
|
|
public function get_newinstance_link($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 NULL;
|
|
}
|
|
|
|
if ($DB->record_exists('enrol', array('courseid'=>$courseid, 'enrol'=>'manual'))) {
|
|
return NULL;
|
|
}
|
|
|
|
return new moodle_url('/enrol/manual/edit.php', array('courseid'=>$courseid));
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
$fields = array(
|
|
'status' => $this->get_config('status'),
|
|
'roleid' => $this->get_config('roleid', 0),
|
|
'enrolperiod' => $this->get_config('enrolperiod', 0),
|
|
'expirynotify' => $this->get_config('expirynotify', 0),
|
|
'notifyall' => $this->get_config('notifyall', 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);
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
|
|
$instance = null;
|
|
$instances = array();
|
|
foreach ($manager->get_enrolment_instances() as $tempinstance) {
|
|
if ($tempinstance->enrol == 'manual') {
|
|
if ($instance === null) {
|
|
$instance = $tempinstance;
|
|
}
|
|
$instances[] = array('id' => $tempinstance->id, 'name' => $this->get_instance_name($tempinstance));
|
|
}
|
|
}
|
|
if (empty($instance)) {
|
|
return false;
|
|
}
|
|
|
|
if (!$manuallink = $this->get_manual_enrol_link($instance)) {
|
|
return false;
|
|
}
|
|
|
|
$button = new enrol_user_button($manuallink, get_string('enrolusers', 'enrol_manual'), 'get');
|
|
$button->class .= ' enrol_manual_plugin';
|
|
|
|
$startdate = $manager->get_course()->startdate;
|
|
$startdateoptions = array();
|
|
$timeformat = get_string('strftimedatefullshort');
|
|
if ($startdate > 0) {
|
|
$startdateoptions[2] = get_string('coursestart') . ' (' . userdate($startdate, $timeformat) . ')';
|
|
}
|
|
$today = time();
|
|
$today = make_timestamp(date('Y', $today), date('m', $today), date('d', $today), 0, 0, 0);
|
|
$startdateoptions[3] = get_string('today') . ' (' . userdate($today, $timeformat) . ')' ;
|
|
$defaultduration = $instance->enrolperiod > 0 ? $instance->enrolperiod / 86400 : '';
|
|
|
|
$modules = array('moodle-enrol_manual-quickenrolment', 'moodle-enrol_manual-quickenrolment-skin');
|
|
$arguments = array(
|
|
'instances' => $instances,
|
|
'courseid' => $instance->courseid,
|
|
'ajaxurl' => '/enrol/manual/ajax.php',
|
|
'url' => $manager->get_moodlepage()->url->out(false),
|
|
'optionsStartDate' => $startdateoptions,
|
|
'defaultRole' => $instance->roleid,
|
|
'defaultDuration' => $defaultduration,
|
|
'disableGradeHistory' => $CFG->disablegradehistory,
|
|
'recoverGradesDefault'=> ''
|
|
);
|
|
|
|
if ($CFG->recovergradesdefault) {
|
|
$arguments['recoverGradesDefault'] = ' checked="checked"';
|
|
}
|
|
|
|
$function = 'M.enrol_manual.quickenrolment.init';
|
|
$button->require_yui_module($modules, $function, array($arguments));
|
|
$button->strings_for_js(array(
|
|
'ajaxoneuserfound',
|
|
'ajaxxusersfound',
|
|
'ajaxnext25',
|
|
'enrol',
|
|
'enrolmentoptions',
|
|
'enrolusers',
|
|
'errajaxfailedenrol',
|
|
'errajaxsearch',
|
|
'none',
|
|
'usersearch',
|
|
'unlimitedduration',
|
|
'startdatetoday',
|
|
'durationdays',
|
|
'enrolperiod',
|
|
'finishenrollingusers',
|
|
'recovergrades'), 'enrol');
|
|
$button->strings_for_js('assignroles', 'role');
|
|
$button->strings_for_js('startingfrom', 'moodle');
|
|
|
|
return $button;
|
|
}
|
|
|
|
/**
|
|
* Enrol cron support.
|
|
* @return void
|
|
*/
|
|
public function cron() {
|
|
$this->sync(null, true);
|
|
$this->send_notifications(true);
|
|
}
|
|
|
|
/**
|
|
* Sync all meta course links.
|
|
*
|
|
* @param int $courseid one course, empty mean all
|
|
* @param bool $verbose verbose CLI output
|
|
* @return int 0 means ok, 1 means error, 2 means plugin disabled
|
|
*/
|
|
public function sync($courseid = null, $verbose = false) {
|
|
global $DB;
|
|
|
|
if (!enrol_is_enabled('manual')) {
|
|
return 2;
|
|
}
|
|
|
|
// Unfortunately this may take a long time, execution can be interrupted safely here.
|
|
@set_time_limit(0);
|
|
raise_memory_limit(MEMORY_HUGE);
|
|
|
|
if ($verbose) {
|
|
mtrace('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);
|
|
if ($verbose) {
|
|
mtrace(" unenrolling expired user $ue->userid from course $instance->courseid");
|
|
}
|
|
}
|
|
$rs->close();
|
|
unset($instances);
|
|
|
|
} else if ($action == ENROL_EXT_REMOVED_SUSPENDNOROLES) {
|
|
$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];
|
|
// 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->update_user_enrol($instance, $ue->userid, ENROL_USER_SUSPENDED);
|
|
if ($verbose) {
|
|
mtrace(" suspending expired user $ue->userid in course $instance->courseid");
|
|
}
|
|
}
|
|
$rs->close();
|
|
unset($instances);
|
|
|
|
} else {
|
|
// ENROL_EXT_REMOVED_KEEP means no changes.
|
|
}
|
|
|
|
if ($verbose) {
|
|
mtrace('...manual enrolment updates finished.');
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Send notifications.
|
|
*
|
|
* @param bool $verbose verbose CLI output
|
|
*/
|
|
public function send_notifications($verbose = false) {
|
|
global $DB, $CFG;
|
|
|
|
// Unfortunately this may take a long time, it should not be interrupted,
|
|
// otherwise users get duplicate notification.
|
|
|
|
@set_time_limit(0);
|
|
raise_memory_limit(MEMORY_HUGE);
|
|
|
|
$notifylast = $this->get_config('notifylast', 0);
|
|
$notifyhour = $this->get_config('notifyhour', 6);
|
|
$timenow = time();
|
|
|
|
$notifytime = usergetmidnight($timenow, $CFG->timezone) + ($notifyhour * 3600);
|
|
|
|
if ($notifylast > $notifytime) {
|
|
if ($verbose) {
|
|
mtrace('Manual enrolment notifications were already sent today at '.userdate($notifylast, '', $CFG->timezone).'.');
|
|
}
|
|
return;
|
|
} else if ($timenow < $notifytime) {
|
|
if ($verbose) {
|
|
mtrace('Manual enrolment notifications will be sent at '.userdate($notifytime, '', $CFG->timezone).'.');
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ($verbose) {
|
|
mtrace('Processing manual enrolment notifications...');
|
|
}
|
|
|
|
// Notify users responsible for enrolment once every day.
|
|
$sql = "SELECT ue.*, e.expirynotify, e.notifyall, e.expirythreshold, e.courseid, c.fullname
|
|
FROM {user_enrolments} ue
|
|
JOIN {enrol} e ON (e.id = ue.enrolid AND e.enrol = 'manual' AND e.expirynotify > 0 AND e.status = :enabled)
|
|
JOIN {course} c ON (c.id = e.courseid)
|
|
JOIN {user} u ON (u.id = ue.userid AND u.deleted = 0 AND u.suspended = 0)
|
|
WHERE ue.status = :active AND ue.timeend > 0 AND ue.timeend > :now1 AND ue.timeend < (e.expirythreshold + :now2)
|
|
ORDER BY ue.enrolid ASC, u.lastname ASC, u.firstname ASC, u.id ASC";
|
|
$params = array('enabled'=>ENROL_INSTANCE_ENABLED, 'active'=>ENROL_USER_ACTIVE, 'now1'=>$timenow, 'now2'=>$timenow);
|
|
|
|
$rs = $DB->get_recordset_sql($sql, $params);
|
|
|
|
$lastenrollid = 0;
|
|
$users = array();
|
|
|
|
foreach($rs as $ue) {
|
|
if ($lastenrollid and $lastenrollid != $ue->enrolid) {
|
|
$this->notify_expiry_enroller($ue->enrolid, $users, $verbose);
|
|
}
|
|
$lastenrollid = $ue->enrolid;
|
|
|
|
$enroller = $this->get_enroller($ue->courseid);
|
|
$context = context_course::instance($ue->courseid);
|
|
|
|
$user = $DB->get_record('user', array('id'=>$ue->userid));
|
|
|
|
$users[] = array('fullname'=>fullname($user, has_capability('moodle/site:viewfullnames', $context, $enroller)), 'timeend'=>$ue->timeend);
|
|
|
|
if (!$ue->notifyall) {
|
|
continue;
|
|
}
|
|
|
|
if ($ue->timeend - $ue->expirythreshold + 86400 < $timenow) {
|
|
// Notify enrolled users only once at the start of the threshold.
|
|
continue;
|
|
}
|
|
|
|
$this->notify_expiry_enrolled($user, $ue, $verbose);
|
|
}
|
|
$rs->close();
|
|
|
|
if ($lastenrollid and $users) {
|
|
$this->notify_expiry_enroller($lastenrollid, $users, $verbose);
|
|
}
|
|
|
|
if ($verbose) {
|
|
mtrace('...notification processing finished.');
|
|
}
|
|
$this->set_config('notifylast', $timenow);
|
|
}
|
|
|
|
/**
|
|
* Returns the user who is responsible for manual enrolments in given course.
|
|
*
|
|
* 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 $courseid
|
|
* @return stdClass user record
|
|
*/
|
|
protected function get_enroller($courseid) {
|
|
if ($this->lasternollercourseid == $courseid and $this->lasternoller) {
|
|
return $this->lasternoller;
|
|
}
|
|
|
|
$context = context_course::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 = get_admin();
|
|
}
|
|
|
|
$this->lasternollercourseid = $courseid;
|
|
|
|
return $this->lasternoller;
|
|
}
|
|
|
|
/**
|
|
* Notify user about incoming expiration of their enrolment,
|
|
* it is called only if notification of enrolled users (aka students) is enabled in course.
|
|
*
|
|
* This is executed only once for each expiring enrolment right
|
|
* at the start of the expiration threshold.
|
|
*
|
|
* @param stdClass $user
|
|
* @param stdClass $ue
|
|
* @param bool $verbose
|
|
*/
|
|
protected function notify_expiry_enrolled($user, $ue, $verbose) {
|
|
global $CFG, $SESSION;
|
|
|
|
// Some nasty hackery to get strings and dates localised for target user.
|
|
$sessionlang = isset($SESSION->lang) ? $SESSION->lang : null;
|
|
if (get_string_manager()->translation_exists($user->lang, false)) {
|
|
$SESSION->lang = $user->lang;
|
|
moodle_setlocale();
|
|
}
|
|
|
|
$enroller = $this->get_enroller($ue->courseid);
|
|
$context = context_course::instance($ue->courseid);
|
|
|
|
$subject = get_string('expirymessageenrolledsubject', 'enrol_manual', null);
|
|
$a = new stdClass();
|
|
$a->course = format_string($ue->fullname, true, array('context'=>$context));
|
|
$a->user = fullname($user, true);
|
|
$a->timeend = userdate($ue->timeend, '', $user->timezone);
|
|
$a->enroller = fullname($enroller, has_capability('moodle/site:viewfullnames', $context, $user));
|
|
$body = get_string('expirymessageenrolledbody', 'enrol_manual', $a);
|
|
|
|
$message = new stdClass();
|
|
$message->notification = 1;
|
|
$message->component = 'enrol_manual';
|
|
$message->name = 'expiry_notification';
|
|
$message->userfrom = $enroller;
|
|
$message->userto = $user;
|
|
$message->subject = $subject;
|
|
$message->fullmessage = $body;
|
|
$message->fullmessageformat = FORMAT_MARKDOWN;
|
|
$message->fullmessagehtml = markdown_to_html($body);
|
|
$message->smallmessage = $subject;
|
|
$message->contexturlname = $a->course;
|
|
$message->contexturl = (string)new moodle_url('/course/view.php', array('id'=>$ue->courseid));
|
|
|
|
if (message_send($message)) {
|
|
if ($verbose) {
|
|
mtrace(" notifying user $ue->userid that enrolment in course $ue->courseid expires on ".userdate($ue->timeend, '', $CFG->timezone));
|
|
}
|
|
} else {
|
|
if ($verbose) {
|
|
mtrace(" error notifying user $ue->userid that enrolment in course $ue->courseid expires on ".userdate($ue->timeend, '', $CFG->timezone));
|
|
}
|
|
}
|
|
|
|
if ($SESSION->lang !== $sessionlang) {
|
|
$SESSION->lang = $sessionlang;
|
|
moodle_setlocale();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notify person responsible for enrolments that some user enrolments will be expired soon,
|
|
* it is called only if notification of enrollers (aka teachers) is enabled in course.
|
|
*
|
|
* This is called repeatedly every day for each course if there are any pending expiration
|
|
* in the expiration threshold.
|
|
*
|
|
* @param int $eid
|
|
* @param array $users
|
|
* @param bool $verbose
|
|
*/
|
|
protected function notify_expiry_enroller($eid, $users, $verbose) {
|
|
global $DB, $SESSION;
|
|
|
|
$instance = $DB->get_record('enrol', array('id'=>$eid, 'enrol'=>'manual'));
|
|
$context = context_course::instance($instance->courseid);
|
|
$course = $DB->get_record('course', array('id'=>$instance->courseid));
|
|
|
|
$enroller = $this->get_enroller($instance->courseid);
|
|
$admin = get_admin();
|
|
|
|
// Some nasty hackery to get strings and dates localised for target user.
|
|
$sessionlang = isset($SESSION->lang) ? $SESSION->lang : null;
|
|
if (get_string_manager()->translation_exists($enroller->lang, false)) {
|
|
$SESSION->lang = $enroller->lang;
|
|
moodle_setlocale();
|
|
}
|
|
|
|
foreach($users as $key=>$info) {
|
|
$users[$key] = '* '.$info['fullname'].' - '.userdate($info['timeend'], '', $enroller->timezone);
|
|
}
|
|
|
|
$subject = get_string('expirymessageenrollersubject', 'enrol_manual', null);
|
|
$a = new stdClass();
|
|
$a->course = format_string($course->fullname, true, array('context'=>$context));
|
|
$a->threshold = get_string('numdays', '', $instance->expirythreshold / (60*60*24));
|
|
$a->users = implode("\n", $users);
|
|
$a->extendurl = (string)new moodle_url('/enrol/users.php', array('id'=>$instance->courseid));
|
|
$body = get_string('expirymessageenrollerbody', 'enrol_manual', $a);
|
|
|
|
$message = new stdClass();
|
|
$message->notification = 1;
|
|
$message->component = 'enrol_manual';
|
|
$message->name = 'expiry_notification';
|
|
$message->userfrom = $admin;
|
|
$message->userto = $enroller;
|
|
$message->subject = $subject;
|
|
$message->fullmessage = $body;
|
|
$message->fullmessageformat = FORMAT_MARKDOWN;
|
|
$message->fullmessagehtml = markdown_to_html($body);
|
|
$message->smallmessage = $subject;
|
|
$message->contexturlname = $a->course;
|
|
$message->contexturl = $a->extendurl;
|
|
|
|
if (message_send($message)) {
|
|
if ($verbose) {
|
|
mtrace(" notifying user $enroller->id about all expiring manual enrolments in course $instance->courseid");
|
|
}
|
|
} else {
|
|
if ($verbose) {
|
|
mtrace(" error notifying user $enroller->id about all expiring manual enrolments in course $instance->courseid");
|
|
}
|
|
}
|
|
|
|
if ($SESSION->lang !== $sessionlang) {
|
|
$SESSION->lang = $sessionlang;
|
|
moodle_setlocale();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an array of the user enrolment actions.
|
|
*
|
|
* @param course_enrolment_manager $manager
|
|
* @param stdClass $ue A user enrolment object
|
|
* @return array An array of user_enrolment_actions
|
|
*/
|
|
public function get_user_enrolment_actions(course_enrolment_manager $manager, $ue) {
|
|
$actions = array();
|
|
$context = $manager->get_context();
|
|
$instance = $ue->enrolmentinstance;
|
|
$params = $manager->get_moodlepage()->url->params();
|
|
$params['ue'] = $ue->id;
|
|
if ($this->allow_unenrol_user($instance, $ue) && has_capability("enrol/manual:unenrol", $context)) {
|
|
$url = new moodle_url('/enrol/unenroluser.php', $params);
|
|
$actions[] = new user_enrolment_action(new pix_icon('t/delete', ''), get_string('unenrol', 'enrol'), $url, array('class'=>'unenrollink', 'rel'=>$ue->id));
|
|
}
|
|
if ($this->allow_manage($instance) && has_capability("enrol/manual:manage", $context)) {
|
|
$url = new moodle_url('/enrol/manual/editenrolment.php', $params);
|
|
$actions[] = new user_enrolment_action(new pix_icon('t/edit', ''), get_string('edit'), $url, array('class'=>'editenrollink', 'rel'=>$ue->id));
|
|
}
|
|
return $actions;
|
|
}
|
|
|
|
/**
|
|
* 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');
|
|
$bulkoperations = array(
|
|
'editselectedusers' => new enrol_manual_editselectedusers_operation($manager, $this),
|
|
'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);
|
|
}
|
|
}
|