/**
* Test student save works when $USER object not set
*/
public function test_student_save_nouserobject()
{
global $DB, $USER;
// Create Moodle course category.
$crscat = create_course_category((object) array('name' => 'Test Course category', 'idnumber' => 'MCC-1'));
// Create Moodle course.
$crsdata = array('category' => $crscat->id, 'fullname' => 'MC-TEST-ELIS-8484', 'shortname' => 'MC-TEST-ELIS-8484', 'idnumber' => 'MC-TEST-ELIS-8484');
$mdlcrs = new stdClass();
$mdlcrs->id = $DB->insert_record('course', (object) $crsdata);
$cddata = array('name' => 'CD-ELIS-8484', 'code' => 'CD-ELIS-8484', 'idnumber' => 'CD-ELIS-8484', 'syllabus' => 'syllabus');
$cd = new course($cddata);
$cd->save();
$ci = new pmclass(array('idnumber' => 'CI-ELIS-8484', 'courseid' => $cd->id, 'moodlecourseid' => $mdlcrs->id, 'autocreate' => 0));
$ci->save();
$testuser = new user(array('idnumber' => 'testuserelis8484', 'username' => 'testuserelis8484', 'firstname' => 'Test', 'lastname' => 'User-ELIS8484', 'email' => '*****@*****.**', 'city' => 'Waterloo', 'country' => 'CA'));
$testuser->save();
$USER = null;
$sturec = new stdClass();
$sturec->userid = $testuser->id;
$sturec->classid = $ci->id;
$sturec->grade = 0;
$sturec->enrolmenttime = time();
$student = new student($sturec);
$student->save();
$this->assertFalse(empty($student));
if (!empty($student)) {
$this->assertFalse(empty($student->id));
}
}
/**
* Save a set of enrolments and LO grades to the database
* @param array $enrolments Enrolment data to save
* @param array $grades LO grade data to save
*/
protected function save_enrolments($enrolments, $grades = array())
{
// Enrolments.
foreach ($enrolments as $enrolment) {
$student = new student($enrolment);
$sink = $this->redirectMessages();
$student->save();
}
// LO grades.
foreach ($grades as $grade) {
$studentgrade = new student_grade($grade);
$studentgrade->save();
}
}
/**
* Method to create test user class enrolment
* @param int $userid the user DB id
* @param int $classid the class DB id
*/
public function create_class_enrolment($userid, $classid)
{
// Initialize version1elis importplugin for utility functions.
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$record = new stdClass();
$record->userid = $userid;
$record->classid = $classid;
$record->completestatusid = 0;
$record->grade = 50;
$record->credits = 1;
$record->locked = 0;
$record->enrolmenttime = $importplugin->parse_date('Jan/10/2013');
$stu = new student($record);
$stu->save();
}
protected function savepass()
{
$required = array("current" => "Current Password", "new" => "New Password");
foreach ($required as $key => $value) {
if (!isset($_POST[$key]) || $_POST[$key] == '' || $_POST[$key] == 'select') {
echo $value . ' is Required<br/>';
return;
}
}
global $user;
global $objPDO;
$student = new student($objPDO, $user->getuserId());
if (md5($_POST['current']) == $student->getPassword()) {
$student->setPassword(md5($_POST['new']));
$student->save();
} else {
echo 'The Current Password is Wrong';
return;
}
echo '<meta http-equiv="Refresh" content="0;url=http://localhost/cloud/profile"/>';
}
/**
* Test successful class enrolment deletion.
*/
public function test_success()
{
global $DB;
$this->give_permissions(array('local/elisprogram:class_enrol'));
// Initialize version1elis importplugin for utility functions.
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
// Create test course and class.
$datagen = new elis_program_datagenerator($DB);
$crs = $datagen->create_course(array('idnumber' => 'TestCourse'));
$cls = $datagen->create_pmclass(array('idnumber' => 'TestClassEnrolmentCreate', 'courseid' => $crs->id));
$data = array('class_idnumber' => $cls->idnumber, 'user_username' => 'assigninguser', 'user_email' => '*****@*****.**');
// Create the class enrolment record to delete.
$userid = $DB->get_field(user::TABLE, 'id', array('username' => 'assigninguser'));
$stu = new student(array('classid' => $cls->id, 'userid' => $userid));
$stu->save();
$response = local_datahub_elis_class_enrolment_delete::class_enrolment_delete($data);
$this->assertNotEmpty($response);
$this->assertInternalType('array', $response);
$this->assertArrayHasKey('messagecode', $response);
$this->assertArrayHasKey('message', $response);
$this->assertEquals(get_string('ws_class_enrolment_delete_success_code', 'local_datahub'), $response['messagecode']);
$this->assertEquals(get_string('ws_class_enrolment_delete_success_msg', 'local_datahub'), $response['message']);
$this->assertFalse($DB->record_exists(student::TABLE, array('classid' => $cls->id, 'userid' => $userid)));
}
/**
* Validate that the method respects the locked status when run for a
* specific user
*/
public function test_methodonlyupdatesunlockedenrolmentsforspecificuserid()
{
global $DB;
$this->load_csv_data();
// Set up enrolments.
$this->make_course_enrollable();
enrol_try_internal_enrol(2, 100, 1);
enrol_try_internal_enrol(2, 101, 1);
// Set required PM course grade.
$pmcourse = new \course(array('id' => 100, 'completion_grade' => 50));
$pmcourse->save();
// Set up course grade item.
$coursegradeitem = \grade_item::fetch_course_item(2);
$coursegradeitem->grademax = 100;
$coursegradeitem->needsupdate = false;
$coursegradeitem->locked = true;
$coursegradeitem->update();
// Assign student grades.
$coursegradegrade = new \grade_grade(array('itemid' => 1, 'userid' => 100, 'finalgrade' => 100));
$coursegradegrade->insert();
$coursegradegrade = new \grade_grade(array('itemid' => 1, 'userid' => 101, 'finalgrade' => 100));
$coursegradegrade->insert();
// Enrol the student.
$student = new \student();
$student->userid = 103;
$student->classid = 100;
$student->grade = 0;
$student->completestatusid = STUSTATUS_NOTCOMPLETE;
$student->locked = 1;
$student->save();
// Call and validate that locked record is not changed.
$sync = new \local_elisprogram\moodle\synchronize();
$sync->synchronize_moodle_class_grades(100);
$this->assert_student_exists(100, 103, 0, STUSTATUS_NOTCOMPLETE, null, null, 1);
$DB->execute("UPDATE {" . \student::TABLE . "} SET locked = 0");
// Call and validate that unlocked record is changed.
$sync = new \local_elisprogram\moodle\synchronize();
$sync->synchronize_moodle_class_grades(100);
// Validate count.
$count = $DB->count_records(\student::TABLE, array('completestatusid' => STUSTATUS_PASSED));
$this->assertEquals(1, $count);
// NOTE: this method does not lock enrolments.
$this->assert_student_exists(100, 103, 100, STUSTATUS_PASSED, null, null, 0);
}
/**
* Enrol the test user in the provided context
*
* @param string $contextlevel The string descriptor of the context level
* @param string $role The shortname of the import record's role column
*/
private function create_enrolment($contextlevel, $role)
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
switch ($contextlevel) {
case 'curriculum':
// Program enrolment.
require_once elispm::lib('data/curriculumstudent.class.php');
$data = array('curriculumid' => 1, 'userid' => 1);
$curriculumstudent = new curriculumstudent($data);
$curriculumstudent->save();
break;
case 'track':
// Track enrolment.
require_once elispm::lib('data/usertrack.class.php');
$data = array('trackid' => 1, 'userid' => 1);
$usertrack = new usertrack($data);
$usertrack->save();
break;
case 'cluster':
// User set enrolment.
require_once elispm::lib('data/clusterassignment.class.php');
$data = array('clusterid' => 1, 'userid' => 1);
$clusterassignment = new clusterassignment($data);
$clusterassignment->save();
break;
case 'class':
if ($role == 'instructor') {
// Class instance instructor enrolment.
require_once elispm::lib('data/instructor.class.php');
$data = array('classid' => 1, 'userid' => 1);
$instructor = new instructor($data);
$instructor->save();
} else {
// Class instance student enrolment.
require_once elispm::lib('data/student.class.php');
$data = array('classid' => 1, 'userid' => 1);
$student = new student($data);
$student->save();
}
break;
case 'user':
// Moodle user role assignment.
$roleid = $DB->get_field('role', 'id', array('shortname' => $role));
$userid = $DB->get_field('user', 'id', array('idnumber' => 'testuseridnumber'));
$context = context_user::instance($userid);
role_assign($roleid, $userid, $context->id);
break;
default:
break;
}
}
/**
* Validate that the check_for_moodle_courses method deletes the correct set of orphaned associations for a specific user.
* @param array $associations The list of associations and information regarding whether they should be cleaned up or not.
* @dataProvider dataprovider_checkformoodlecourses
*/
public function test_checkformoodlecoursesrespectsuseridparameter($associations)
{
global $DB;
// Set up our classes.
$this->load_csv_data();
$student = new student(array('userid' => 103, 'classid' => 103));
$sink = $this->redirectMessages();
$student->save();
// Track which associations should remain.
$remainingassociations = array();
foreach ($associations as $association) {
// Persist the record.
$record = new classmoodlecourse($association);
$record->save();
// Test user is enrolled in class 103, so this one should be deleted.
if ($association['classid'] != 103) {
// It should persist after the method is called.
$remainingassociations[] = $association;
}
}
// Delete orphaned records.
pmclass::check_for_moodle_courses(103);
// Validate count.
$this->assertEquals(count($remainingassociations), $DB->count_records(classmoodlecourse::TABLE));
// Validate records specifically.
foreach ($remainingassociations as $remainingassociation) {
$params = array('classid' => $remainingassociation['classid'], 'moodlecourseid' => $remainingassociation['moodlecourseid']);
$exists = $DB->record_exists(classmoodlecourse::TABLE, $params);
$this->assertTrue($exists);
}
}
/**
* Validate that the pm_update_enrolment_status method respects its userid parameter, i.e. it can run only for a specific user.
* NOTE: this unit test does not test all cases because that should be specifically tested for $pmclass->update_enrolment_status
*
* @param array $enrolments A list of class enrolment records we are processing
* @param array $classgraded A list of learning objective grades we are processing
* @dataProvider dataprovider_updatedelegation
*/
public function test_pmupdateenrolmentstatusrespectsuseridparameter($enrolments, $classgraded)
{
global $DB;
// Necessary data.
$this->load_csv_data();
foreach ($enrolments as $key => $enrolment) {
// Create student enrolment.
$record = new student($enrolment);
$record->save();
}
foreach ($classgraded as $lograde) {
// Create learning objective grade.
$record = new student_grade($lograde);
$record->save();
}
// Pass the appropriate student.
pm_update_enrolment_status(2);
// We should have one passed student in the PM class instance, and that student should be the second user.
$enrolments = $DB->get_records(student::TABLE, array('completestatusid' => STUSTATUS_PASSED));
$this->assertEquals(1, count($enrolments));
$enrolment = reset($enrolments);
$this->assertEquals(100, $enrolment->classid);
$this->assertEquals(2, $enrolment->userid);
$this->assertEquals(100, $enrolment->grade);
}
/**
* Validate the "succss" case of the method, i.e. failing students for a specific user id, i.e. can only for a specific user.
*
* @param array $associations A list of enrolments / associations to validate against.
* @dataProvider dataprovider_enrolmentfail
*/
public function test_pmupdatestudentenrolmentfailsstudentwithspecificuserid($associations)
{
global $DB;
// Prevent messaging emails from being sent.
set_config('noemailever', true);
// Necessary data.
$this->load_csv_data();
// Track the final data state for validation.
$expectedassociations = array();
foreach ($associations as $key => $association) {
// Create student enrolment.
$record = new student($association);
$record->save();
if ($association['userid'] == 1) {
// Specific student will be set to failed.
$expectedassociations[] = $association;
$expectedassociations[$key]['completestatusid'] = STUSTATUS_FAILED;
// Hard to reliably test timestamps.
unset($expectedassociations[$key]['completetime']);
}
}
// Fail specific expired students.
$this->quiet_pm_update_student_enrolment(1);
// Validate count.
$this->assertEquals(count($expectedassociations), $DB->count_records(student::TABLE, array('userid' => 1)));
// Validate data specifically.
foreach ($expectedassociations as $expectedassociation) {
$exists = $DB->record_exists(student::TABLE, $expectedassociation);
$this->assertTrue($exists);
}
}
/**
* Updates resulting enrolments that are auto-created after users are
* assigned to user sets (specifically user-track assignments, user-program
* assignments, and class enrolments in a track's default class)
*
* Note: This is essentially equivalent to cluster_assigned_handler but
* runs a fixed number of queries for scalability reasons
*
* @param int $userid A specific PM user id to filter on for
* consideration, or all users if zero
* @param int $clusterid A specific cluster / user set id to filter
* on for consideration, or all users if zero
*/
static function update_enrolments($userid = 0, $clusterid = 0)
{
global $DB;
require_once elispm::lib('data/usermoodle.class.php');
// error_log("/local/elisprogram/lib/data/clusterassignment.class.php::update_enrolments({$userid}, {$clusterid})");
// ELIS-7582
@set_time_limit(0);
// convert provided parameters to SQL conditions
$extraconditions = array();
$extraparams = array();
if (!empty($userid)) {
$users = array($userid);
$extraconditions[] = 'u.id = ?';
$extraparams[] = $userid;
} else {
$users = clusterassignment::find(new field_filter('clusterid', $clusterid));
}
if (!empty($clusterid)) {
$extraconditions[] = 'clu.clusterid = ?';
$extraparams[] = $clusterid;
}
$extrawhere = '';
if (!empty($extraconditions)) {
$extrawhere = ' AND ' . implode(' AND ', $extraconditions);
}
//use the current time as the time created and modified for curriculum
//assignments
$timenow = time();
//assign to curricula based on user-cluster and cluster-curriculum
//associations
$sql = "INSERT INTO {" . curriculumstudent::TABLE . "}\n (userid, curriculumid, timecreated, timemodified)\n SELECT DISTINCT u.id, clucur.curriculumid, {$timenow}, {$timenow}\n FROM {" . clusterassignment::TABLE . "} clu\n JOIN {" . user::TABLE . "} u ON u.id = clu.userid\n JOIN {" . clustercurriculum::TABLE . "} clucur\n ON clucur.clusterid = clu.clusterid\n LEFT JOIN {" . curriculumstudent::TABLE . "} ca\n ON ca.userid = u.id\n AND ca.curriculumid = clucur.curriculumid\n WHERE ca.curriculumid IS NULL\n AND clucur.autoenrol = 1\n {$extrawhere}";
$DB->execute($sql, $extraparams);
//assign to curricula based on user-cluster and cluster-track
//associations (assigning a user to a track auto-assigns them to
//the track's curriculum, track assignment happens below)
$sql = "INSERT INTO {" . curriculumstudent::TABLE . "}\n (userid, curriculumid, timecreated, timemodified)\n SELECT DISTINCT u.id, trk.curid, {$timenow}, {$timenow}\n FROM {" . clusterassignment::TABLE . "} clu\n JOIN {" . user::TABLE . "} u\n ON u.id = clu.userid\n JOIN {" . clustertrack::TABLE . "} clutrk\n ON clutrk.clusterid = clu.clusterid\n JOIN {" . track::TABLE . "} trk\n ON clutrk.trackid = trk.id\n LEFT JOIN {" . curriculumstudent::TABLE . "} ca\n ON ca.userid = u.id\n AND ca.curriculumid = trk.curid\n WHERE ca.curriculumid IS NULL\n AND clutrk.autoenrol = 1\n {$extrawhere}";
$DB->execute($sql, $extraparams);
//this represents the tracks that users will be assigned to
//based on user-cluster and cluster-track associations
//(actual assignment happens below)
$exists = "EXISTS (SELECT DISTINCT u.id, clutrk.trackid\n FROM {" . clusterassignment::TABLE . "} clu\n JOIN {" . user::TABLE . "} u\n ON u.id = clu.userid\n JOIN {" . clustertrack::TABLE . "} clutrk\n ON clutrk.clusterid = clu.clusterid\n LEFT JOIN {" . usertrack::TABLE . "} ta\n ON ta.userid = u.id\n AND ta.trackid = clutrk.trackid\n WHERE ta.trackid IS NULL\n AND clutrk.autoenrol = 1\n AND outerta.trackid = clutrk.trackid\n\t {$extrawhere})";
/**
* Get autoenrollable classes in the track. Classes are autoenrollable
* if:
* - the autoenrol flag is set
* - it is the only class in that course slot for the track
*/
// group the classes from the same course together
// only select the ones that are the only class for that course in
// the given track, and if the autoenrol flag is set
$sql = "SELECT outerta.classid, outerta.courseid, trk.curid\n FROM {" . trackassignment::TABLE . "} outerta\n JOIN {" . track::TABLE . "} trk ON trk.id = outerta.trackid\n WHERE {$exists}\n GROUP BY courseid\n HAVING COUNT(*) = 1 AND MAX(autoenrol) = 1";
//go through and assign user(s) to the autoenollable classes
$classes = $DB->get_records_sql($sql, $extraparams);
if (!empty($classes)) {
foreach ($users as $user) {
$userid = is_object($user) ? $user->userid : $user;
foreach ($classes as $class) {
// check pre-requisites
$curcrs = new curriculumcourse(array('courseid' => $class->courseid, 'curriculumid' => $class->curid));
if (!$curcrs->prerequisites_satisfied($userid)) {
continue;
}
$now = time();
// enrol user in each autoenrolable class
$stu_record = new object();
$stu_record->userid = $userid;
$stu_record->classid = $class->classid;
$stu_record->enrolmenttime = $now;
$enrolment = new student($stu_record);
// catch enrolment limits
try {
$enrolment->save();
} catch (pmclass_enrolment_limit_validation_exception $e) {
// autoenrol into waitlist
$wait_record = new object();
$wait_record->userid = $userid;
$wait_record->classid = $class->classid;
$wait_record->enrolmenttime = $now;
$wait_record->timecreated = $now;
$wait_record->position = 0;
$wait_list = new waitlist($wait_record);
$wait_list->save();
} catch (Exception $e) {
$param = array('message' => $e->getMessage());
if (in_cron()) {
mtrace(get_string('record_not_created_reason', 'local_elisprogram', $param));
} else {
echo cm_error(get_string('record_not_created_reason', 'local_elisprogram', $param));
}
}
}
}
}
//assign to tracks based on user-cluster and cluster-track
//associations
$sql = "INSERT INTO {" . usertrack::TABLE . "}\n (userid, trackid)\n SELECT DISTINCT u.id, clutrk.trackid\n FROM {" . clusterassignment::TABLE . "} clu\n JOIN {" . user::TABLE . "} u\n ON u.id = clu.userid\n JOIN {" . clustertrack::TABLE . "} clutrk\n ON clutrk.clusterid = clu.clusterid\n LEFT JOIN {" . usertrack::TABLE . "} ta\n ON ta.userid = u.id\n AND ta.trackid = clutrk.trackid\n WHERE ta.trackid IS NULL\n AND clutrk.autoenrol = 1\n {$extrawhere}";
$DB->execute($sql, $extraparams);
//update site-level "cluster groups"
//TODO: make sure all "cluster groups" scenarios are handled here, and look at
//performance in more detal
if (!empty($userid) && file_exists(elispm::file('plugins/usetgroups/lib.php'))) {
require_once elispm::file('plugins/usetgroups/lib.php');
//need the Moodle user id
$mdluserid = $DB->get_field(usermoodle::TABLE, 'muserid', array('cuserid' => $userid));
if ($mdluserid) {
//find all assignments for this user
$assignments = $DB->get_recordset(clusterassignment::TABLE, array('userid' => $userid));
foreach ($assignments as $assignment) {
//update site-level group assignments
userset_groups_update_site_course($assignment->clusterid, true, $mdluserid);
}
}
//update course-level group assignment
userset_groups_update_groups(array('mdlusr.cuserid' => $userid));
}
}
$student->semester = '0';
$student->verband = 'I';
$student->gruppe = ' ';
$student->insertamum = date('Y-m-d H:i:s');
$student->insertvon = $user;
$lvb = new lehrverband();
if (!$lvb->exists($student->studiengang_kz, $student->semester, $student->verband, $student->gruppe)) {
$lvb->studiengang_kz = $student->studiengang_kz;
$lvb->semester = $student->semester;
$lvb->verband = $student->verband;
$lvb->gruppe = $student->gruppe;
$lvb->bezeichnung = 'Incoming';
$lvb->aktiv = true;
$lvb->save(true);
}
if ($student->save(true, false)) {
//StudentLehrverband anlegen
$studentlehrverband = new student();
$studentlehrverband->uid = $uid;
$studentlehrverband->studiensemester_kurzbz = $studiensemester_kurzbz;
$studentlehrverband->studiengang_kz = $studiengang_kz;
$studentlehrverband->semester = '0';
$studentlehrverband->verband = 'I';
$studentlehrverband->gruppe = ' ';
$studentlehrverband->insertamum = date('Y-m-d H:i:s');
$studentlehrverband->insertvon = $user;
if (!$studentlehrverband->save_studentlehrverband(true)) {
$error = true;
$errormsg = 'StudentLehrverband konnte nicht angelegt werden';
}
} else {
/**
* Test the autoenrol after course completion function.
*/
public function test_check_autoenrol_after_course_completion()
{
$dataset = $this->createCsvDataSet(array(course::TABLE => elispm::file('tests/fixtures/pmcourse.csv'), pmclass::TABLE => elispm::file('tests/fixtures/pmclass.csv'), user::TABLE => elispm::file('tests/fixtures/pmuser.csv'), student::TABLE => elispm::file('tests/fixtures/student.csv'), waitlist::TABLE => elispm::file('tests/fixtures/waitlist2.csv')));
$this->loadDataSet($dataset);
$class = new pmclass(100);
$class->load();
$class->maxstudents = 2;
$class->enrol_from_waitlist = 1;
$class->save();
$student = new student(array('userid' => 103, 'classid' => 100));
$student->completestatusid = STUSTATUS_PASSED;
$student->save();
$return = waitlist::check_autoenrol_after_course_completion($student);
$this->assertTrue($return);
}
/**
* Perform an update for a single user/class pair.
*
* @param int $userid The user ID we're updating.
* @param int $classid The class ID we're updating information for.
* @param array $enroldata The updated enrolment data.
* @param array $learningobjectives The updated learning objective data.
*/
protected function do_update($userid, $classid, array $enroldata, array $learningobjectives)
{
global $DB;
if (student::can_manage_assoc($userid, $classid) !== true) {
throw new Exception('Unauthorized');
}
if (!isset($enroldata['id'])) {
$associationid = $DB->get_field(student::TABLE, 'id', array('classid' => $classid, 'userid' => $userid));
if (empty($associationid)) {
return false;
} else {
$enroldata['id'] = $associationid;
}
}
$enroldata['userid'] = $userid;
$stu = new student($enroldata);
if ($stu->completestatusid == STUSTATUS_PASSED && $DB->get_field(student::TABLE, 'completestatusid', array('id' => $stu->id)) != STUSTATUS_PASSED) {
$stu->complete();
} else {
$status = $stu->save();
}
foreach ($learningobjectives as $id => $data) {
$graderec = array('userid' => $userid, 'classid' => $classid, 'completionid' => $id);
$existingrec = $DB->get_record(student_grade::TABLE, $graderec);
if (!empty($existingrec)) {
$graderec = (array) $existingrec;
}
$graderec['timegraded'] = $data['timegraded'];
$graderec['grade'] = $data['grade'];
$graderec['locked'] = $data['locked'];
$sgrade = new student_grade($graderec);
$sgrade->save();
}
}
/**
* Attempt initial enrolment.
*
* This performs an initial attempt at enroling the selected users. This has not yet taken into account the enrolment limit
* or permissions.
*
* @param array $elements An array of elements to perform the action on.
* @param int $classid The ID of the class we're enrolling into.
* @param string $enroldata A JSON string containing enrolment data for the users we want to overenrol.
* @param bool $bulkaction Whether this attempt is a bulk action or not.
* @return array An array consisting of "result", and optionally "users" and "total", explained below:
* result: Will be "success" if all users were enrolled successfully, or "waitlist", if we have users that
* need to be waitlisted.
* users: If some users need enrolment limit resolution, this will be present.
* This will either contain an array of arrays like array('userid' => $userid, 'name' => $label),
* or the string 'bulklist', if we're performing a bulk action.
* total: If we're performing a bulk action, and some users need enrolment limit resolution, this will be
* included, indicating the number of users needed resolution.
*/
protected function attempt_enrolment($elements, $classid, $enroldata, $bulkaction)
{
set_time_limit(0);
// Enrolment data.
$enroldata = $this->process_enrolment_data($classid, @json_decode($enroldata));
if (empty($enroldata)) {
throw new Exception('Did not receive valid enrolment data.');
}
// Attempt enrolment.
$waitlist = array();
foreach ($elements as $userid => $label) {
// Skip invalid userids or users which we dont have permission to modify.
if (!is_numeric($userid) || !student::can_manage_assoc($userid, $classid)) {
continue;
}
// Build student.
$sturecord = $enroldata;
$sturecord['userid'] = $userid;
$newstu = new student($sturecord);
$newstu->validation_overrides[] = 'prerequisites';
if ($newstu->completestatusid != STUSTATUS_NOTCOMPLETE) {
// User is set to completed, so don't worry about enrolment limit.
$newstu->validation_overrides[] = 'enrolment_limit';
}
// Attempt enrolment.
try {
$newstu->save();
unset($elements[$userid]);
$this->datatable->bulklist_modify(array(), array($userid));
} catch (pmclass_enrolment_limit_validation_exception $e) {
$waitlist[] = array('userid' => $userid, 'name' => $label);
} catch (Exception $e) {
$param = array('message' => $e->getMessage());
throw new Exception(get_string('record_not_created_reason', 'local_elisprogram', $param));
}
}
if ($bulkaction === true) {
if (!empty($waitlist)) {
list($bulklistdisplay, $totalusers) = $this->datatable->bulklist_get_display(1);
return array('result' => 'waitlist', 'users' => 'bulklist', 'total' => $totalusers);
} else {
return array('result' => 'success');
}
} else {
return !empty($waitlist) ? array('result' => 'waitlist', 'users' => $waitlist) : array('result' => 'success');
}
}
/**
* Performs class_enrolment creation
* @throws moodle_exception If there was an error in passed parameters.
* @throws data_object_exception If there was an error creating the entity.
* @param array $data The incoming data parameter.
* @return array An array of parameters, if successful.
*/
public static function class_enrolment_create(array $data)
{
global $USER, $DB;
if (static::require_elis_dependencies() !== true) {
throw new moodle_exception('ws_function_requires_elis', 'local_datahub');
}
static $completestatuses = array('not completed' => STUSTATUS_NOTCOMPLETE, 'not_completed' => STUSTATUS_NOTCOMPLETE, 'notcompleted' => STUSTATUS_NOTCOMPLETE, 'failed' => 'STUSTATUS_FAILED', 'passed' => STUSTATUS_PASSED);
// Parameter validation.
$params = self::validate_parameters(self::class_enrolment_create_parameters(), array('data' => $data));
// Context validation.
$context = context_user::instance($USER->id);
self::validate_context($context);
$data = (object) $data;
// Parse class
if (empty($data->class_idnumber) || !($classid = $DB->get_field(pmclass::TABLE, 'id', array('idnumber' => $data->class_idnumber)))) {
throw new data_object_exception('ws_class_enrolment_create_fail_invalid_class', 'local_datahub', '', $data);
}
// Capability checking.
require_capability('local/elisprogram:class_enrol', \local_elisprogram\context\pmclass::instance($classid));
// Initialize version1elis importplugin for utility functions.
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$userparams = array();
$userid = $importplugin->get_userid_from_record($data, '', $userparams);
if ($userid == false) {
$a = new stdClass();
if (empty($userparams)) {
$a->userparams = '{empty}';
} else {
$a->userparams = '';
foreach ($userparams as $userfield => $uservalue) {
$subfield = strpos($userfield, '_');
$userfield = substr($userfield, $subfield === false ? 0 : $subfield + 1);
if (!empty($a->userparams)) {
$a->userparams .= ', ';
}
$a->userparams .= "{$userfield}: '{$uservalue}'";
}
}
throw new data_object_exception('ws_class_enrolment_create_fail_invalid_user', 'local_datahub', '', $a);
}
$record = new stdClass();
$record->userid = $userid;
$record->classid = $classid;
$record->completestatusid = STUSTATUS_NOTCOMPLETE;
if (isset($data->completestatus)) {
$completestatus = strtolower($data->completestatus);
if (isset($completestatuses[$completestatus])) {
$record->completestatusid = $completestatuses[$completestatus];
} else {
throw new data_object_exception('ws_class_enrolment_create_fail_invalid_completestatus', 'local_datahub', '', $data);
}
}
$record->grade = isset($data->grade) && is_numeric($data->grade) ? $data->grade : 0;
$record->credits = isset($data->credits) && is_numeric($data->credits) ? $data->credits : 0;
$record->locked = !empty($data->locked) ? 1 : 0;
if (isset($data->enrolmenttime)) {
$enrolmenttime = $importplugin->parse_date($data->enrolmenttime);
if (empty($enrolmenttime)) {
throw new data_object_exception('ws_class_enrolment_create_fail_invalid_enrolmenttime', 'local_datahub', '', $data);
} else {
$record->enrolmenttime = $enrolmenttime;
}
} else {
$record->enrolmenttime = rlip_timestamp();
}
$record->completetime = 0;
if (isset($data->completetime)) {
$completetime = $importplugin->parse_date($data->completetime);
if (empty($completetime)) {
throw new data_object_exception('ws_class_enrolment_create_fail_invalid_completetime', 'local_datahub', '', $data);
} else {
$record->completetime = $completetime;
}
} else {
if (!empty($record->completestatusid)) {
$record->completetime = rlip_timestamp();
}
}
$stu = new student($record);
$stu->save();
// Respond.
if (!empty($stu->id)) {
return array('messagecode' => get_string('ws_class_enrolment_create_success_code', 'local_datahub'), 'message' => get_string('ws_class_enrolment_create_success_msg', 'local_datahub'), 'record' => $stu->to_array());
} else {
throw new data_object_exception('ws_class_enrolment_create_fail', 'local_datahub');
}
}
/**
* Validate that a success message is logged on enrolment delete
*/
public function testenrolmentdeletelogssuccessmessage()
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/data/course.class.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/data/pmclass.class.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/data/student.class.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/data/user.class.php';
$course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$course->save();
$pmclass = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclassidnumber'));
$pmclass->save();
$user = new user(array('idnumber' => 'testuseridnumber', 'username' => 'testuserusername', 'firstname' => 'testuserfirstname', 'lastname' => 'testuserlastname', 'email' => '*****@*****.**', 'country' => 'CA'));
$user->save();
$student = new student(array('classid' => $pmclass->id, 'userid' => $user->id));
$student->save();
$record = new stdClass();
// TODO: consider using fewer fields.
$record->context = 'class_testclassidnumber';
$record->user_idnumber = 'testuseridnumber';
$record->user_username = '******';
$record->user_email = '*****@*****.**';
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$importplugin->dblogger = new rlip_dblogger_import(false);
$importplugin->fslogger = new silent_fslogger(null);
$importplugin->class_enrolment_delete_student($record, 'bogus', 'testclassidnumber');
$importplugin->dblogger->flush('bogus');
$expectedmessage = 'All lines from import file bogus were successfully processed.';
$where = 'statusmessage = ?';
$exists = $DB->record_exists_select(RLIP_LOG_TABLE, $where, array($expectedmessage));
$this->assertTrue($exists);
}
/**
* Validate that users can be enrolled from class instances (when assigned as a student)
*
* @param string $username A sample user's username, or null if not used in the import
* @param string $email A sample user's email, or null if not used in the import
* @param string $idnumber A sample user's idnumber, or null if not used in the import
* @dataProvider user_identifier_provider
*/
public function test_elis_user_student_unenrolment_import($actioncreate, $actiondelete, $username, $email, $idnumber)
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elispm::lib('data/course.class.php');
require_once elispm::lib('data/pmclass.class.php');
require_once elispm::lib('data/student.class.php');
require_once elispm::lib('data/user.class.php');
set_config('noemailever', true);
$user = new user(array('idnumber' => 'testuseridnumber', 'username' => 'testuserusername', 'firstname' => 'testuserfirstname', 'lastname' => 'testuserlastname', 'email' => '*****@*****.**', 'country' => 'CA'));
$user->save();
$course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$course->save();
$class = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclassidnumber'));
$class->save();
$student = new student(array('userid' => $user->id, 'classid' => $class->id, 'enrolmenttime' => 0));
$student->save();
// Validate setup.
$this->assertTrue($DB->record_exists(student::TABLE, array('userid' => $user->id, 'classid' => $class->id)));
// Run the student enrolment delete action.
$record = new stdClass();
$record->action = $actiondelete;
$record->context = 'class_testclassidnumber';
if ($username != null) {
$record->user_username = $user->username;
}
if ($email != null) {
$record->user_email = $user->email;
}
if ($idnumber != null) {
$record->user_idnumber = $user->idnumber;
}
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$importplugin->fslogger = new silent_fslogger(null);
$importplugin->process_record('enrolment', (object) $record, 'bogus');
// Validation.
$this->assertEquals(0, $DB->count_records(student::TABLE));
}
/**
* When a role is selected from the sync configuration, create class
* enrolments for the specified role assignments.
*/
static function student_sync_role_set()
{
global $DB;
$roleid = get_config('elisprogram_enrolrolesync', 'student_role');
if (empty($roleid)) {
//not configured
return;
}
//include dependencies
require_once elispm::lib('data/student.class.php');
// find all class role assignments
$sql = "SELECT ra.id, cu.id AS userid, ctx.instanceid AS classid\n FROM {role_assignments} ra\n JOIN {user} mu ON ra.userid = mu.id\n JOIN {" . user::TABLE . "} cu ON mu.idnumber = cu.idnumber\n JOIN {context} ctx ON ctx.id = ra.contextid\n LEFT JOIN {" . student::TABLE . "} stu\n ON cu.id = stu.userid\n AND ctx.instanceid = stu.classid\n WHERE ctx.contextlevel = :contextlevel\n AND ra.roleid = :roleid\n AND stu.id IS NULL";
$params = array('contextlevel' => CONTEXT_ELIS_CLASS, 'roleid' => $roleid);
$studentswanted = $DB->get_recordset_sql($sql, $params);
$studentswanted = $studentswanted ? $studentswanted : array();
//iterate and add where needed
foreach ($studentswanted as $student) {
unset($student->id);
$student = new student($student);
$student->enrolmenttime = time();
try {
$student->save();
} catch (Exception $e) {
//validation failed
}
}
return true;
}
/**
* Validate that createorupdate still works when the class idnumber contains
* an underscore
*/
public function testeliscreateorupdatesupportsunderscores()
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elispm::lib('data/course.class.php');
require_once elispm::lib('data/pmclass.class.php');
require_once elispm::lib('data/student.class.php');
require_once elispm::lib('data/user.class.php');
// Set up initial conditions.
set_config('createorupdate', 1, 'dhimport_version1elis');
// Create the test course.
$course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$course->save();
// Create the test class.
$class = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclass_idnumber'));
$class->save();
// Create the test user.
$user = new user(array('username' => 'testuserusername', 'email' => '*****@*****.**', 'idnumber' => 'testuseridnumber', 'firstname' => 'testuserfirstname', 'lastname' => 'testuserlastname', 'country' => 'CA'));
$user->save();
// Set up an existing enrolment.
$student = new student(array('userid' => $user->id, 'classid' => $class->id, 'completestatusid' => student::STUSTATUS_FAILED));
$student->save();
// Import the record, with create acting as an update.
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$importplugin->fslogger = new silent_fslogger(null);
$record = new stdClass();
$record->action = 'create';
$record->context = 'class_testclass_idnumber';
$record->user_idnumber = 'testuseridnumber';
$record->completestatusid = student::STUSTATUS_PASSED;
$importplugin->process_record('enrolment', $record, 'bogus');
// Validation.
$this->assertEquals(1, $DB->count_records(student::TABLE));
$params = array('userid' => $user->id, 'classid' => $class->id, 'completestatusid' => student::STUSTATUS_PASSED);
$exists = $DB->record_exists(student::TABLE, $params);
$this->assertTrue($exists);
}
}
$studiengang = new studiengang();
if (!$studiengang->load($student->studiengang_kz)) {
die('Fehler beim Laden des Studienganges');
}
if (!$rechte->isBerechtigt('student/stammdaten', $studiengang->oe_kurzbz, 'su')) {
die('Sie haben keine Berechtigung fuer diese Aktion');
}
$student->matrikelnr = $matrikelnummer;
$student->semester = $semester;
$student->verband = $verband;
$student->gruppe = $gruppe;
$student->updateamum = date('Y-m-d H:i:s');
$student->updatevon = $user;
$student->new = false;
if ($student->save(null, false)) {
$msg = '<h3>Daten wurden erfolgreich gespeichert</h3>';
} else {
$msg = "<h3>Fehler beim Speichern der Daten: {$student->errormsg}</h3>";
$error_student_save = true;
}
}
$person = new person();
if (!$person->load($person_id)) {
die('Person wurde nicht gefunden');
}
echo "<h2>Details von {$person->vorname} {$person->nachname}</h2>";
echo $msg;
if (!$error_person_save) {
$anrede = $person->anrede;
$titelpre = $person->titelpre;
/**
* Test sync_coursegrade method.
*
* @dataProvider dataprovider_sync_coursegrade
* @param array $sturec Array of parameters to create student record.
* @param array $coursegradeitem Array of parameters to create course grade_item.
* @param array $coursegradegrade Array of parameters to create course grade_grade.
* @param array $compelements Array of completion elements for the linked ELIS course/class.
* @param array $completiongrade The grade a student must exceed to be marked as passed.
* @param array $credits The number of credits a successful student will receive.
* @param array $timenow The current timestamp, to enable testing with time.
* @param array $expectedsyncedstudent Array of parameters we expect on the student grade record.
*/
public function test_sync_coursegrade($sturec, $coursegradeitem, $coursegradegrade, array $compelements = array(), $completiongrade, $credits, $timenow, $expectedsyncedstudent)
{
global $DB;
$crs = new \course(array('idnumber' => 'CRS1', 'name' => 'Course 1', 'syllabus' => ''));
$crs->save();
$cls = new \pmclass(array('courseid' => $crs->id, 'idnumber' => 'CLS1'));
$cls->save();
$usr = new \user(array('username' => 'test1', 'idnumber' => 'test2', 'firstname' => 'test', 'lastname' => 'user', 'email' => '*****@*****.**', 'country' => 'CA'));
$usr->save();
$sturec['classid'] = $cls->id;
$sturec['userid'] = $usr->id;
$sturec = new \student($sturec);
$sturec->save();
$sturec = new \student($sturec->id);
$sturec->load();
$sturec = $sturec->to_object();
$musr = $this->getDataGenerator()->create_user();
$coursegradeitem = new \grade_item($coursegradeitem, false);
$coursegradeitem->insert();
$coursegradegrade['userid'] = $musr->id;
$coursegradegrade['itemid'] = $coursegradeitem->id;
$coursegradegrade = new \grade_grade($coursegradegrade, false);
$coursegradegrade->insert();
foreach ($compelements as $i => $compelement) {
$compelement['courseid'] = $crs->id;
$compelements[$i] = new \coursecompletion($compelement);
$compelements[$i]->save();
}
$sync = new \local_elisprogram\moodle\synchronize();
$sync->sync_coursegrade($sturec, $coursegradeitem, $coursegradegrade, $compelements, $completiongrade, $credits, $timenow);
$syncedsturec = $DB->get_record(\student::TABLE, array('id' => $sturec->id));
$expectedrec = array('id' => $sturec->id, 'classid' => (string) $cls->id, 'userid' => (string) $usr->id, 'enrolmenttime' => '0', 'completetime' => 0, 'endtime' => '0', 'completestatusid' => (string) STUSTATUS_NOTCOMPLETE, 'grade' => '0.00000', 'credits' => '0.00', 'locked' => '0');
$expectedrec = (object) array_merge($expectedrec, $expectedsyncedstudent);
$this->assertEquals($expectedrec, $syncedsturec);
}
/**
* Validating that updating a user's enrolment in a class instance triggers the enrolment
* notification if the status is set to passed
*
* @param int $oldcompletestatus The completion status to enrol the user with initially
* @param int $newcompletestatus The completion status to set during enrolment update
* @param boolean $expectmessage Whether we expect the notification message to be sent
* @dataProvider enrolment_completion_on_update_provider
*/
public function test_class_completion_sends_class_completed_notification_on_enrolment_update($oldcompletestatus, $newcompletestatus, $expectmessage)
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elispm::lib('data/course.class.php');
require_once elispm::lib('data/pmclass.class.php');
require_once elispm::lib('data/user.class.php');
// Force refreshing of configuration.
elis::$config = new elis_config();
// Configuration.
set_config('popup_provider_elis_program_notify_pm_permitted', 1, 'message');
set_config('email_provider_elis_program_notify_pm_permitted', 1, 'message');
set_config('notify_classcompleted_user', 1, 'local_elisprogram');
$message = '%%userenrolname%% has completed the class instance %%classname%%.';
set_config('notify_classcompleted_message', $message, 'local_elisprogram');
$this->setAdminUser();
unset_config('noemailever');
// Setup.
$user = new user(array('idnumber' => 'testuseridnumber', 'username' => 'testuserusername', 'firstname' => 'testuserfirstname', 'lastname' => 'testuserlastname', 'email' => '*****@*****.**', 'country' => 'CA'));
$user->save();
$course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$course->save();
$class = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclassidnumber'));
$class->save();
// We need an "existing" enrolment record set up.
$student = new student(array('userid' => $user->id, 'classid' => $class->id, 'completestatusid' => $oldcompletestatus));
$sink = $this->redirectEmails();
$student->save();
if ($oldcompletestatus !== student::STUSTATUS_PASSED) {
$this->assertEquals(0, count($sink->get_messages()));
} else {
$this->assertEquals(1, count($sink->get_messages()));
}
$sink->close();
$DB->delete_records('message');
// Run the enrolment update action.
$record = new stdClass();
$record->context = 'class_testclassidnumber';
$record->user_username = '******';
$record->completestatusid = $newcompletestatus;
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$importplugin->fslogger = new silent_fslogger(null);
$sink = $this->redirectEmails();
$importplugin->class_enrolment_update($record, 'bogus', 'testclassidnumber');
if ($oldcompletestatus !== $newcompletestatus) {
$this->assertEquals(1, count($sink->get_messages()));
} else {
$this->assertEquals(0, count($sink->get_messages()));
}
$sink->close();
// Validation.
$mdluserid = $DB->get_field('user', 'id', array('username' => 'testuserusername'));
$expectedmessage = "{$user->firstname} {$user->lastname} has completed the class instance {$course->name}.";
$like = $DB->sql_like('fullmessagehtml', ':message');
$select = "useridto = :userid\n AND {$like}";
if ($expectmessage) {
$this->assertTrue($DB->record_exists_select('message', $select, array('userid' => $mdluserid, 'message' => "{$expectedmessage}%")));
} else {
$this->assertFalse($DB->record_exists_select('message', $select, array('userid' => $mdluserid, 'message' => "{$expectedmessage}%")));
}
}
/**
* Test table doesn't show assigned students or instructors
* @dataProvider dataprovider_available_doesnt_show_students_instructors
* @param array $associations An array of arrays of parameters to construct student associations.
* @param int $tableclassid The ID of the class we're managing.
* @param array $expectedresults The expected page of results.
*/
public function test_available_doesnt_show_students_instructors($students, $instructors, $tableclassid, $expectedresults)
{
global $USER, $DB, $CFG;
$userbackup = $USER;
// Set up permissions.
$USER = $this->setup_permissions_test();
$this->give_permission_for_context($USER->id, 'local/elisprogram:assign_class_instructor', context_system::instance());
// Create associations.
foreach ($students as $student) {
$student = new student($student);
$student->save();
}
foreach ($instructors as $instructor) {
$instructor = new instructor($instructor);
$instructor->save();
}
$table = new deepsight_datatable_instructor_available_mock($DB, 'test', 'http://localhost', 'testuniqid');
$table->set_classid($tableclassid);
$actualresults = $table->get_search_results(array(), array(), 0, 20);
$this->assert_search_results($expectedresults, count($expectedresults), $actualresults);
// Restore user.
$USER = $userbackup;
}
/**
* Enrols a user in a track.
*
* @param int $userid The user id
* @param int $trackid The track id
*/
public static function enrol($userid, $trackid)
{
global $DB;
// make sure we don't double-enrol
if ($DB->record_exists(self::TABLE, array('userid' => $userid, 'trackid' => $trackid))) {
return false;
}
$record = new usertrack();
$record->userid = $userid;
$record->trackid = $trackid;
$record->save();
$user = new user($userid);
$track = new track($trackid);
if (!$DB->record_exists(curriculumstudent::TABLE, array('userid' => $userid, 'curriculumid' => $track->curid))) {
$curstu = new curriculumstudent();
$curstu->userid = $userid;
$curstu->curriculumid = $track->curid;
$curstu->completed = 0;
$curstu->credits = 0;
$curstu->locked = 0;
$curstu->save();
}
events_trigger('track_assigned', $record);
/**
* Get autoenrollable classes in the track. Classes are autoenrollable
* if:
* - the autoenrol flag is set
* - it is the only class in that course slot for the track
*/
$sql = 'SELECT classid, courseid ' . 'FROM {' . trackassignment::TABLE . '} ' . 'WHERE trackid = ? ' . 'GROUP BY courseid ' . 'HAVING COUNT(*) = 1 AND MAX(autoenrol) = 1';
$params = array($trackid);
$classes = $DB->get_recordset_sql($sql, $params);
foreach ($classes as $class) {
// ELIS-3460: check pre-requisites ...
$curcrs = new curriculumcourse(array('courseid' => $class->courseid, 'curriculumid' => $track->curid));
if (!$curcrs->prerequisites_satisfied($userid)) {
//error_log("/local/elisprogram/lib/data/usertrack.class.php::enrol({$userid}); pre-requisites NOT satisfied for course: {$class->courseid}, curriculum: {$track->curid}");
continue;
}
$now = time();
// enrol user in each autoenrolable class
$stu_record = new object();
$stu_record->userid = $userid;
$stu_record->classid = $class->classid;
$stu_record->enrolmenttime = $now;
$enrolment = new student($stu_record);
// catch enrolment limits
try {
$status = $enrolment->save();
} catch (pmclass_enrolment_limit_validation_exception $e) {
// autoenrol into waitlist
$wait_record = new object();
$wait_record->userid = $userid;
$wait_record->classid = $class->classid;
$wait_record->enrolmenttime = $now;
$wait_record->timecreated = $now;
$wait_record->position = 0;
$wait_list = new waitlist($wait_record);
$wait_list->save();
$status = true;
} catch (Exception $e) {
$param = array('message' => $e->getMessage());
echo cm_error(get_string('record_not_created_reason', 'local_elisprogram', $param));
}
}
unset($classes);
return true;
}
/**
* Update a student class instance enrolment
*
* @param object $record One record of import data
* @param string $filename The import file name, used for logging
* @param string $idnumber The idnumber of the class instance
*
* @return boolean true on success, otherwise false
*/
public function class_enrolment_update_student($record, $filename, $idnumber)
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elispm::lib('data/pmclass.class.php');
require_once elispm::lib('data/student.class.php');
if (!($crsid = $DB->get_field(pmclass::TABLE, 'id', array('idnumber' => $idnumber)))) {
$this->fslogger->log_failure("instance value of \"{$idnumber}\" does not refer to a valid instance of a class context.", 0, $filename, $this->linenumber, $record, "enrolment");
return false;
}
if (!$this->validate_class_enrolment_data('update', $record, $filename)) {
return false;
}
//obtain the class id
$classid = $DB->get_field(pmclass::TABLE, 'id', array('idnumber' => $idnumber));
//obtain the user id
$userid = $this->get_userid_from_record($record, $filename);
//update the record
$id = $DB->get_field(student::TABLE, 'id', array('classid' => $classid, 'userid' => $userid));
$student = new student($id);
//need to call load because saving a student needs the full object for events
//and dynamic loading will blow away changes otherwise
$student->load();
$student->userid = $userid;
//enrolment and completion times
if (isset($record->enrolmenttime)) {
$student->enrolmenttime = $this->parse_date($record->enrolmenttime);
}
if (isset($record->completetime)) {
$student->completetime = $this->parse_date($record->completetime);
}
$completestatusid = $this->get_completestatusid($record);
//set up a completion status, if set
if ($completestatusid !== NULL) {
$student->completestatusid = $completestatusid;
}
if (isset($record->grade)) {
$student->grade = $record->grade;
}
if (isset($record->credits)) {
$student->credits = $record->credits;
}
if (isset($record->locked)) {
$student->locked = $record->locked;
}
//TODO: consider refactoring once ELIS-6546 is resolved
if (isset($student->completestatusid) && $student->completestatusid == STUSTATUS_PASSED && $DB->get_field(student::TABLE, 'completestatusid', array('id' => $student->id)) != STUSTATUS_PASSED) {
$student->complete();
} else {
try {
$student->save();
} catch (Exception $e) {
// Student save may attempt to sync ELIS user to Moodle.
$useridnumber = $student->users->idnumber;
$this->fslogger->log_failure("Error creating associated Moodle user for idnumber \"{$useridnumber}\": " . $e->getMessage(), 0, $filename, $this->linenumber, $record, "enrolment");
return false;
}
}
//string to describe the user
$user_descriptor = $this->get_user_descriptor($record, false, 'user_');
//log success
$success_message = "Student enrolment for user with {$user_descriptor} in class instance \"{$idnumber}\" successfully updated.";
$this->fslogger->log_success($success_message, 0, $filename, $this->linenumber);
return true;
}
function enrol_all_track_users_in_class()
{
// find all users who are not enrolled in the class
// TODO: validate this...
$sql = "NOT EXISTS (SELECT 'x'\n FROM {" . student::TABLE . "} s\n WHERE s.classid = ? AND s.userid = {" . usertrack::TABLE . "}.userid)\n AND trackid = ?";
$params = array($this->classid, $this->trackid);
$users = $this->_db->get_recordset_select(usertrack::TABLE, $sql, $params, 'userid');
if ($users->valid() === true) {
// ELIS-7582
@set_time_limit(0);
$timenow = time();
$count = 0;
$waitlisted = 0;
$prereq = 0;
foreach ($users as $user) {
// enrol user in track
$enrol = new student();
$enrol->classid = $this->classid;
$enrol->userid = $user->userid;
$enrol->enrolmenttime = $timenow;
try {
$enrol->save();
$count++;
} catch (unsatisfied_prerequisites_exception $ex) {
$prereq++;
} catch (pmclass_enrolment_limit_validation_exception $ex) {
// autoenrol into waitlist
$wait_record = new stdClass();
$wait_record->userid = $user->userid;
$wait_record->classid = $this->classid;
//$wait_record->enrolmenttime = $timenow;
$wait_record->timecreated = $timenow;
$wait_record->position = 0;
$wait_list = new waitlist($wait_record);
$wait_list->save();
$waitlisted++;
}
}
print_string('n_users_enrolled', 'local_elisprogram', $count);
if ($waitlisted) {
print_string('n_users_waitlisted', 'local_elisprogram', $waitlisted);
}
if ($prereq) {
print_string('n_users_unsatisfied_prereq', 'local_elisprogram', $prereq);
}
} else {
print_string('all_users_already_enrolled', 'local_elisprogram');
}
unset($users);
}
/**
*
* @global object $CFG
* @uses $CFG
* @uses $OUTPUT
*/
public function enrol()
{
global $CFG;
$class = new pmclass($this->classid);
// enrol directly in the course
$student = new student();
// TBD: new student($this); didn't work!!!
$student->userid = $this->userid;
$student->classid = $this->classid;
$student->enrolmenttime = max(time(), $class->startdate);
// Disable validation rules for prerequisites and enrolment_limits
$student->validation_overrides[] = 'prerequisites';
$student->validation_overrides[] = 'enrolment_limit';
$courseid = $class->get_moodle_course_id();
if ($courseid) {
$course = $this->_db->get_record('course', array('id' => $courseid));
// check that the elis plugin allows for enrolments from the course
// catalog -- if not, see if there are other plugins that allow
// self-enrolment.
$plugin = enrol_get_plugin('elis');
$enrol = $plugin->get_or_create_instance($course);
if (!$enrol->{enrol_elis_plugin::ENROL_FROM_COURSE_CATALOG_DB}) {
// get course enrolment plugins, and see if any of them allow self-enrolment
$enrols = enrol_get_plugins(true);
$enrolinstances = enrol_get_instances($course->id, true);
foreach ($enrolinstances as $instance) {
if (!isset($enrols[$instance->enrol])) {
continue;
}
$form = $enrols[$instance->enrol]->enrol_page_hook($instance);
if ($form) {
// at least one plugin allows self-enrolment -- send
// the user to the course enrolment page, and prevent
// automatic enrolment
$a = new stdClass();
$a->id = $course->id;
$a->idnumber = $class->idnumber;
$a->wwwroot = $CFG->wwwroot;
$subject = get_string('moodleenrol_subj', self::LANG_FILE, $a);
$message = get_string('moodleenrol', self::LANG_FILE, $a);
$student->no_moodle_enrol = true;
break;
}
}
}
}
$student->save();
// Send notification, if enabled.
$sendnotification = !empty(elis::$config->local_elisprogram->notify_enroledfromwaitlist_user) ? true : false;
if ($sendnotification === true) {
if (!isset($message)) {
$a = new stdClass();
$a->idnum = $class->idnumber;
$subject = get_string('nowenroled', self::LANG_FILE, $a);
$message = get_string('nowenroled', self::LANG_FILE, $a);
}
$cuser = new user($this->userid);
$cuser->load();
$from = get_admin();
notification::notify($message, $cuser, $from);
}
$this->delete();
}
/**
* Validate that mappings are applied during the student enrolment delete action
*/
public function test_mapping_applied_during_student_enrolment_delete()
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/data/course.class.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/data/pmclass.class.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/data/student.class.php';
$this->init_mapping();
$userid = $this->create_test_user();
$course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$course->save();
$pmclass = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclassidnumber'));
$pmclass->save();
$student = new student(array('classid' => $pmclass->id, 'userid' => $userid));
$student->save();
// Run the student enrolment delete action.
$record = new stdClass();
$record->customaction = 'delete';
$record->customcontext = 'class_testclassidnumber';
$record->customuser_username = '******';
$record->customuser_email = '*****@*****.**';
$record->customuser_idnumber = 'testuseridnumber';
$record->customrole = 'student';
$this->run_enrolment_import((array) $record);
// Validation.
$this->assertEquals(0, $DB->count_records(student::TABLE));
}
function display_savenew()
{
// action_savenew()
global $USER, $CFG, $DB;
$clsid = cm_get_param('clsid', 0);
$class = new pmclass($clsid);
$now = time();
if (!$class->is_enrollable()) {
print_error('notenrollable', 'enrol');
// TBD
}
// check if class is full
if (!empty($class->maxstudents) && student::count_enroled($class->id) >= $class->maxstudents) {
$form = $this->create_waitlistform($classid);
$form->display();
return;
}
// call the Moodle enrolment plugin if attached to a Moodle course, and
// it's not the elis plugin
//todo: check Moodle enrolment plugins here
$cuserid = cm_get_crlmuserid($USER->id);
$sturecord = array();
$sturecord['classid'] = $class->id;
$sturecord['userid'] = $cuserid;
// Set the enrolment time from class startdate if it's in the future or just set
// current time if class has an associated Moodle course that has already started
$enrolmenttime = $class->startdate;
if ($moodlecourseid = moodle_get_course($clsid)) {
if ($startdate = $DB->get_field('course', 'startdate', array('id' => $moodlecourseid))) {
$enrolmenttime = $startdate < $now ? $now : $class->startdate;
}
}
$sturecord['enrolmenttime'] = max($now, $enrolmenttime);
$sturecord['completetime'] = 0;
$newstu = new student($sturecord);
$courseid = $class->get_moodle_course_id();
if ($courseid) {
$course = $DB->get_record('course', array('id' => $courseid));
// check that the elis plugin allows for enrolments from the course
// catalog -- if not, see if there are other plugins that allow
// self-enrolment.
$plugin = enrol_get_plugin('elis');
$enrol = $plugin->get_or_create_instance($course);
if (!$enrol->{enrol_elis_plugin::ENROL_FROM_COURSE_CATALOG_DB}) {
// get course enrolment plugins, and see if any of them allow self-enrolment
$enrols = enrol_get_plugins(true);
$enrolinstances = enrol_get_instances($course->id, true);
foreach ($enrolinstances as $instance) {
if (!isset($enrols[$instance->enrol])) {
continue;
}
$form = $enrols[$instance->enrol]->enrol_page_hook($instance);
if ($form) {
// at least one plugin allows self-enrolment -- send
// the user to the course enrolment page, and prevent
// automatic enrolment
$newstu->no_moodle_enrol = true;
$newstu->save();
redirect("{$CFG->wwwroot}/course/enrol.php?id={$courseid}");
return;
}
}
}
}
$newstu->save();
$tmppage = new coursecatalogpage(array('action' => 'default'));
redirect($tmppage->url);
}
