/**
* Test successful userset delete
*/
public function test_success()
{
global $DB;
// Create custom field.
$fieldcat = new field_category();
$fieldcat->name = 'Test';
$fieldcat->save();
$field = new field();
$field->categoryid = $fieldcat->id;
$field->shortname = 'testfield';
$field->name = 'Test Field';
$field->datatype = 'text';
$field->save();
$fieldctx = new field_contextlevel();
$fieldctx->fieldid = $field->id;
$fieldctx->contextlevel = CONTEXT_ELIS_USERSET;
$fieldctx->save();
$this->give_permissions(array('local/elisprogram:userset_delete'));
$userset = array('name' => 'testuserset', 'recursive' => true);
// Setup userset to delete.
$us = new userset(array('name' => 'testuserset'));
$us->save();
$response = local_datahub_elis_userset_delete::userset_delete($userset);
$this->assertNotEmpty($response);
$this->assertInternalType('array', $response);
$this->assertArrayHasKey('messagecode', $response);
$this->assertArrayHasKey('message', $response);
$this->assertEquals(get_string('ws_userset_delete_success_code', 'local_datahub', get_string('ws_userset_delete_recursive', 'local_datahub')), $response['messagecode']);
$this->assertEquals(get_string('ws_userset_delete_success_msg', 'local_datahub', get_string('ws_userset_delete_subsets', 'local_datahub')), $response['message']);
}
/**
* Test successful program delete
*/
public function test_success()
{
global $DB;
// Create custom field.
$fieldcat = new field_category();
$fieldcat->name = 'Test';
$fieldcat->save();
$field = new field();
$field->categoryid = $fieldcat->id;
$field->shortname = 'testfield';
$field->name = 'Test Field';
$field->datatype = 'text';
$field->save();
$fieldctx = new field_contextlevel();
$fieldctx->fieldid = $field->id;
$fieldctx->contextlevel = CONTEXT_ELIS_PROGRAM;
$fieldctx->save();
// Create test program to delete.
$cur = new curriculum(array('idnumber' => 'testprogram', 'name' => 'testprogram'));
$cur->save();
$program = array('idnumber' => 'testprogram');
$this->give_permissions(array('local/elisprogram:program_delete'));
$response = local_datahub_elis_program_delete::program_delete($program);
$this->assertNotEmpty($response);
$this->assertInternalType('array', $response);
$this->assertArrayHasKey('messagecode', $response);
$this->assertArrayHasKey('message', $response);
$this->assertEquals(get_string('ws_program_delete_success_code', 'local_datahub'), $response['messagecode']);
$this->assertEquals(get_string('ws_program_delete_success_msg', 'local_datahub'), $response['message']);
$this->assertFalse($DB->record_exists(curriculum::TABLE, array('idnumber' => 'testprogram')));
}
/**
* Create a custom field category
*
* @return int The database id of the new category
*/
private function create_custom_field_category()
{
global $CFG;
require_once $CFG->dirroot . '/local/eliscore/lib/data/customfield.class.php';
$category = new field_category(array('name' => 'testcategoryname'));
$category->save();
return $category->id;
}
/**
* Set up an ELIS custom field category.
* @return field_category The created field category.
*/
protected function set_up_elis_field_category()
{
$data = new stdClass();
$data->name = \local_eliscore\context\helper::get_class_for_level(CONTEXT_ELIS_USER) . ' Test';
$category = new field_category($data);
$category->save();
$categorycontext = new field_category_contextlevel();
$categorycontext->categoryid = $category->id;
$categorycontext->contextlevel = CONTEXT_ELIS_USER;
$categorycontext->save();
return $category;
}
/**
* Test successful course update.
*/
public function test_success()
{
global $DB;
// Create custom field.
$fieldcat = new field_category();
$fieldcat->name = 'Test';
$fieldcat->save();
$field = new field();
$field->categoryid = $fieldcat->id;
$field->shortname = 'testfield';
$field->name = 'Test Field';
$field->datatype = 'text';
$field->save();
$fieldctx = new field_contextlevel();
$fieldctx->fieldid = $field->id;
$fieldctx->contextlevel = CONTEXT_ELIS_COURSE;
$fieldctx->save();
// Grant permissions.
$this->give_permissions(array('local/elisprogram:course_edit'));
// Create test program.
$datagen = new elis_program_datagenerator($DB);
$program = $datagen->create_program(array('idnumber' => 'TestProgram'));
// Create test course to update.
$crs = new course(array('idnumber' => 'TestCourse', 'name' => 'Test Course', 'syllabus' => ''));
$crs->save();
$course = array('idnumber' => 'TestCourse', 'name' => 'Test Course', 'code' => 'CRS1', 'syllabus' => 'Test syllabus', 'lengthdescription' => 'Weeks', 'length' => 2, 'credits' => 1.1, 'completion_grade' => 50, 'cost' => '$100', 'version' => '1.0.0', 'assignment' => $program->idnumber);
// Update test course.
$response = local_datahub_elis_course_update::course_update($course);
$this->assertNotEmpty($response);
$this->assertInternalType('array', $response);
$this->assertArrayHasKey('messagecode', $response);
$this->assertArrayHasKey('message', $response);
$this->assertArrayHasKey('record', $response);
$this->assertEquals(get_string('ws_course_update_success_code', 'local_datahub'), $response['messagecode']);
$this->assertEquals(get_string('ws_course_update_success_msg', 'local_datahub'), $response['message']);
$this->assertInternalType('array', $response['record']);
$this->assertArrayHasKey('id', $response['record']);
// Get course.
$updatedcourse = new course($response['record']['id']);
$updatedcourse->load();
$updatedcourse = $updatedcourse->to_array();
foreach ($course as $param => $val) {
if ($param != 'assignment') {
$this->assertArrayHasKey($param, $updatedcourse);
$this->assertEquals($val, $updatedcourse[$param]);
}
}
// Check that course was assigned to program.
$curriculumcourseid = $DB->get_field(curriculumcourse::TABLE, 'id', array('curriculumid' => $program->id, 'courseid' => $response['record']['id']));
$this->assertNotEmpty($curriculumcourseid);
}
/**
* Create the necessary custom field
*
* @return int The id of the created field
*/
private function create_custom_field()
{
global $CFG;
require_once $CFG->dirroot . '/local/eliscore/lib/data/customfield.class.php';
require_once $CFG->dirroot . '/local/elisprogram/accesslib.php';
// Field category.
$fieldcategory = new field_category(array('name' => 'testcategoryname'));
$fieldcategory->save();
// Custom field.
$field = new field(array('categoryid' => $fieldcategory->id, 'shortname' => 'testfieldshortname', 'name' => 'testfieldname', 'datatype' => 'bool'));
$field->save();
// Field context level assocation.
$fieldcontextlevel = new field_contextlevel(array('fieldid' => $field->id, 'contextlevel' => CONTEXT_ELIS_USER));
$fieldcontextlevel->save();
return $field->id;
}
/**
* Set up necessary data
*
* @param int $numfields The number of custom fields used in auto-association
*/
private function init_required_data($numfields = 1)
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elis::file('eliscore/fields/moodleprofile/custom_fields.php');
require_once elis::lib('data/customfield.class.php');
require_once elispm::file('accesslib.php');
require_once elispm::lib('data/userset.class.php');
require_once $CFG->dirroot . '/user/profile/definelib.php';
require_once $CFG->dirroot . '/user/profile/field/checkbox/define.class.php';
// Set up the category only once.
$fieldcategory = new field_category(array('name' => 'testcategoryname'));
$fieldcategory->save();
// Ste up the target userset only once.
$userset = new userset(array('name' => 'testusersetname'));
$userset->save();
for ($i = 1; $i <= $numfields; $i++) {
// Custom field.
$field = new field(array('categoryid' => $fieldcategory->id, 'shortname' => 'testfieldshortname' . $i, 'name' => 'testfieldname' . $i, 'datatype' => 'bool'));
$field->save();
// Ensure manual field owner exists for syncing.
field_owner::ensure_field_owner_exists($field, 'manual');
$ownerid = $DB->get_field(field_owner::TABLE, 'id', array('fieldid' => $field->id, 'plugin' => 'manual'));
$owner = new field_owner($ownerid);
$owner->param_control = 'checkbox';
$owner->save();
// Ensure moodle profile field owner exists.
field_owner::ensure_field_owner_exists($field, 'moodle_profile');
$DB->execute("UPDATE {" . field_owner::TABLE . "} SET exclude = ?", array(pm_moodle_profile::sync_to_moodle));
// Field context level assocation.
$fieldcontextlevel = new field_contextlevel(array('fieldid' => $field->id, 'contextlevel' => CONTEXT_ELIS_USER));
$fieldcontextlevel->save();
// The associated Moodle user profile field.
$profiledefinecheckbox = new profile_define_checkbox();
$data = new stdClass();
$data->datatype = 'checkbox';
$data->categoryid = 99999;
$data->shortname = 'testfieldshortname' . $i;
$data->name = 'testfieldname' . $i;
$profiledefinecheckbox->define_save($data);
$mfield = $DB->get_record('user_info_field', array('shortname' => 'testfieldshortname' . $i));
// The "cluster-profile" association.
$usersetprofile = new userset_profile(array('clusterid' => $userset->id, 'fieldid' => $mfield->id, 'value' => 1));
$usersetprofile->save();
}
}
/**
* Test successful user creation.
*/
public function test_success()
{
global $DB;
$this->give_permissions(array('local/elisprogram:class_edit'));
// Create custom field.
$fieldcat = new field_category();
$fieldcat->name = 'Test';
$fieldcat->save();
$field = new field();
$field->categoryid = $fieldcat->id;
$field->shortname = 'testfield';
$field->name = 'Test Field';
$field->datatype = 'text';
$field->save();
$fieldctx = new field_contextlevel();
$fieldctx->fieldid = $field->id;
$fieldctx->contextlevel = CONTEXT_ELIS_CLASS;
$fieldctx->save();
$course = new course();
$course->idnumber = 'testcourse1';
$course->name = 'Test Course 1';
$course->syllabus = 'Test';
$course->save();
$class = new pmclass(array('idnumber' => 'testclass', 'startdate' => 1357016400, 'enddate' => 1359694800, 'courseid' => $course->id, 'assignment' => $course->idnumber, 'field_testfield' => 'Test Field'));
$class->save();
$classupdates = array('idnumber' => 'testclass', 'startdate' => 'Feb/04/2013', 'enddate' => 'Mar/01/2013', 'field_testfield' => 'Test Field 2');
$response = local_datahub_elis_class_update::class_update($classupdates);
$this->assertNotEmpty($response);
$this->assertInternalType('array', $response);
$this->assertArrayHasKey('messagecode', $response);
$this->assertArrayHasKey('message', $response);
$this->assertArrayHasKey('record', $response);
$this->assertEquals(get_string('ws_class_update_success_code', 'local_datahub'), $response['messagecode']);
$this->assertEquals(get_string('ws_class_update_success_msg', 'local_datahub'), $response['message']);
$this->assertInternalType('array', $response['record']);
$this->assertArrayHasKey('id', $response['record']);
// Get class.
$expectedclass = array('idnumber' => $class->idnumber, 'startdate' => rlip_timestamp(0, 0, 0, 2, 4, 2013), 'enddate' => rlip_timestamp(0, 0, 0, 3, 1, 2013), 'courseid' => $course->id, 'field_testfield' => 'Test Field 2');
$createdclass = new pmclass($response['record']['id']);
$createdclass->load();
$createdclass = $createdclass->to_array();
foreach ($expectedclass as $param => $val) {
$this->assertArrayHasKey($param, $createdclass);
$this->assertEquals($val, $createdclass[$param]);
}
}
/**
* Test successful user edit.
* @dataProvider dataprovider_success
* @param array $update Incoming update data.
*/
public function test_success($update)
{
global $DB;
$this->give_permissions(array('local/elisprogram:user_edit'));
// Create custom field.
$fieldcat = new field_category();
$fieldcat->name = 'Test';
$fieldcat->save();
$field = new field();
$field->categoryid = $fieldcat->id;
$field->shortname = 'testfield';
$field->name = 'Test Field';
$field->datatype = 'text';
$field->save();
$fieldctx = new field_contextlevel();
$fieldctx->fieldid = $field->id;
$fieldctx->contextlevel = CONTEXT_ELIS_USER;
$fieldctx->save();
$user = array('idnumber' => 'testuser', 'username' => 'testuser', 'firstname' => 'testuser', 'lastname' => 'testuser', 'email' => '*****@*****.**', 'country' => 'CA', 'field_testfield' => 'Test Field');
$user = new user($user);
$user->save();
$expecteduser = (array) $DB->get_record(user::TABLE, array('id' => $user->id));
$expecteduser = array_merge($expecteduser, $update);
$response = local_datahub_elis_user_update::user_update($update);
// Verify general response structure.
$this->assertNotEmpty($response);
$this->assertInternalType('array', $response);
$this->assertArrayHasKey('messagecode', $response);
$this->assertArrayHasKey('message', $response);
$this->assertArrayHasKey('record', $response);
// Verify response message/code.
$this->assertEquals(get_string('ws_user_update_success_code', 'local_datahub'), $response['messagecode']);
$this->assertEquals(get_string('ws_user_update_success_msg', 'local_datahub'), $response['message']);
// Verify returned user information.
$this->assertInternalType('array', $response['record']);
$this->assertArrayHasKey('id', $response['record']);
$actualuser = $DB->get_record(user::TABLE, array('id' => $response['record']['id']));
$this->assertNotEmpty($actualuser);
$actualuser = (array) $actualuser;
// Unset timemodified as it's unreliable to test.
unset($actualuser['timemodified']);
foreach ($actualuser as $param => $val) {
$this->assertEquals($expecteduser[$param], $val);
}
}
/**
* Test that the function will return the existing category if one exists for the given name and contextlevel.
*/
public function test_return_existing()
{
global $DB;
$name = 'Test Category';
$contextlevel = CONTEXT_ELIS_USER;
$cat = new field_category();
$cat->name = $name;
$cat->save();
$catctx = new field_category_contextlevel();
$catctx->categoryid = $cat->id;
$catctx->contextlevel = $contextlevel;
$catctx->save();
$this->assertNotEmpty($this->get_for_name_and_contextlevel($name, $contextlevel));
$cat2 = field_category::ensure_exists_for_contextlevel($name, $contextlevel);
$this->assertNotEmpty($cat2);
$this->assertEquals($cat->id, $cat2->id);
$this->assertEquals($cat->name, $cat2->name);
}
/**
* Test successful track update
*/
public function test_success()
{
global $DB;
// Create custom field.
$fieldcat = new field_category();
$fieldcat->name = 'Test';
$fieldcat->save();
$field = new field();
$field->categoryid = $fieldcat->id;
$field->shortname = 'testfield';
$field->name = 'Test Field';
$field->datatype = 'text';
$field->save();
$fieldctx = new field_contextlevel();
$fieldctx->fieldid = $field->id;
$fieldctx->contextlevel = CONTEXT_ELIS_TRACK;
$fieldctx->save();
$this->give_permissions(array('local/elisprogram:track_edit'));
// Setup program and track.
$datagen = new elis_program_datagenerator($DB);
$program = $datagen->create_program(array('idnumber' => 'test_program_idnumber', 'name' => 'ProgramName'));
$track = $datagen->create_track(array('idnumber' => 'testtrack', 'name' => 'testtrackname', 'curid' => $program->id));
// Perform update.
$trackupdatedata = array('idnumber' => $track->idnumber, 'name' => 'testtrackname_changed', 'description' => 'testtrack description', 'field_testfield' => 'Test field');
$response = local_datahub_elis_track_update::track_update($trackupdatedata);
$this->assertNotEmpty($response);
$this->assertInternalType('array', $response);
$this->assertArrayHasKey('messagecode', $response);
$this->assertArrayHasKey('message', $response);
$this->assertArrayHasKey('record', $response);
$this->assertEquals(get_string('ws_track_update_success_code', 'local_datahub'), $response['messagecode']);
$this->assertEquals(get_string('ws_track_update_success_msg', 'local_datahub'), $response['message']);
$this->assertInternalType('array', $response['record']);
$this->assertArrayHasKey('id', $response['record']);
// Get Track.
$updatedtrk = new track($response['record']['id']);
$updatedtrk->load();
$updatedtrk = $updatedtrk->to_array();
$expecttrk = array('id' => $response['record']['id'], 'idnumber' => 'testtrack', 'name' => 'testtrackname_changed', 'curid' => $program->id, 'description' => 'testtrack description', 'field_testfield' => 'Test field');
foreach ($expecttrk as $param => $val) {
$this->assertArrayHasKey($param, $updatedtrk);
$this->assertEquals($val, $updatedtrk[$param]);
}
}
/**
* Test successful userset update
*/
public function test_success()
{
global $DB;
// Create custom field.
$fieldcat = new field_category();
$fieldcat->name = 'Test';
$fieldcat->save();
$field = new field();
$field->categoryid = $fieldcat->id;
$field->shortname = 'testfield';
$field->name = 'Test Field';
$field->datatype = 'text';
$field->save();
$fieldctx = new field_contextlevel();
$fieldctx->fieldid = $field->id;
$fieldctx->contextlevel = CONTEXT_ELIS_USERSET;
$fieldctx->save();
$this->give_permissions(array('local/elisprogram:userset_edit'));
$userset = array('name' => 'testuserset', 'display' => 'test userset description', 'parent' => 'top', 'field_testfield' => 'Test field');
// Setup userset to update.
$us = new userset(array('name' => 'testuserset'));
$us->save();
$response = local_datahub_elis_userset_update::userset_update($userset);
$this->assertNotEmpty($response);
$this->assertInternalType('array', $response);
$this->assertArrayHasKey('messagecode', $response);
$this->assertArrayHasKey('message', $response);
$this->assertArrayHasKey('record', $response);
$this->assertEquals(get_string('ws_userset_update_success_code', 'local_datahub'), $response['messagecode']);
$this->assertEquals(get_string('ws_userset_update_success_msg', 'local_datahub'), $response['message']);
$this->assertInternalType('array', $response['record']);
$this->assertArrayHasKey('id', $response['record']);
// Get Userset.
$updatedus = new userset($response['record']['id']);
$updatedus->load();
$updatedus = $updatedus->to_array();
$expectus = array('id' => $response['record']['id'], 'name' => 'testuserset', 'display' => 'test userset description', 'parent' => 0, 'field_testfield' => 'Test field');
foreach ($expectus as $param => $val) {
$this->assertArrayHasKey($param, $updatedus);
$this->assertEquals($val, $updatedus[$param]);
}
}
/**
* Test make_from_moodle_field function.
*
* @dataProvider dataprovider_make_from_moodle_field
* @param object $mfielddata Data to create the initial moodle profile with.
* @param array $expectedfielddata Expected data created for the field.
* @param array $expectedmanualownerdata Expected field_owner data created.
*/
public function test_make_from_moodle_field($mfielddata, $expectedfielddata, $expectedmanualownerdata)
{
require_once elis::file('eliscore/lib/data/customfield.class.php');
require_once elis::file('eliscore/fields/moodleprofile/custom_fields.php');
global $DB;
$mfieldid = $DB->insert_record('user_info_field', $mfielddata);
$fieldcat = new field_category();
$fieldcat->name = 'Moodle Fields';
$fieldcat->save();
$efield = field::make_from_moodle_field($mfieldid, $fieldcat, pm_moodle_profile::sync_from_moodle);
$efieldrec = $DB->get_record(field::TABLE, array('shortname' => $efield->shortname));
unset($efieldrec->id);
unset($efieldrec->sortorder);
$expectedfielddata['categoryid'] = (string) $fieldcat->id;
$this->assertEquals($expectedfielddata, (array) $efieldrec);
$manualowner = $DB->get_record(field_owner::TABLE, array('fieldid' => $efield->id, 'plugin' => 'manual'));
ksort($expectedmanualownerdata);
$actualparams = unserialize($manualowner->params);
ksort($actualparams);
$this->assertEquals($expectedmanualownerdata, $actualparams);
$this->assertTrue(moodle_profile_can_sync($efield->shortname));
if ($mfielddata['defaultdata'] != '') {
switch ($efield->datatype) {
case 'bool':
$fielddatatype = 'int';
break;
case 'datetime':
$fielddatatype = 'int';
break;
case 'char':
$fielddatatype = 'char';
break;
default:
$fielddatatype = 'text';
}
$fielddataclass = 'field_data_' . $fielddatatype;
$defaultdata = $DB->get_record($fielddataclass::TABLE, array('fieldid' => $efield->id));
$this->assertNotEmpty($defaultdata);
$this->assertEquals($mfielddata['defaultdata'], $defaultdata->data);
}
}
/**
* Test successful program update
*/
public function test_success()
{
global $DB;
// Create custom field.
$fieldcat = new field_category();
$fieldcat->name = 'Test';
$fieldcat->save();
$field = new field();
$field->categoryid = $fieldcat->id;
$field->shortname = 'testfield';
$field->name = 'Test Field';
$field->datatype = 'text';
$field->save();
$fieldctx = new field_contextlevel();
$fieldctx->fieldid = $field->id;
$fieldctx->contextlevel = CONTEXT_ELIS_PROGRAM;
$fieldctx->save();
// Create test program to update.
$datagen = new elis_program_datagenerator($DB);
$program = $datagen->create_program(array('idnumber' => 'testprogram', 'name' => 'testprogram'));
$program = array('idnumber' => 'testprogram', 'name' => 'newtestprogramname', 'reqcredits' => 4.5, 'timetocomplete' => '6m', 'frequency' => '1y', 'field_testfield' => 'Test Field');
$this->give_permissions(array('local/elisprogram:program_edit'));
$response = local_datahub_elis_program_update::program_update($program);
$this->assertNotEmpty($response);
$this->assertInternalType('array', $response);
$this->assertArrayHasKey('messagecode', $response);
$this->assertArrayHasKey('message', $response);
$this->assertArrayHasKey('record', $response);
$this->assertEquals(get_string('ws_program_update_success_code', 'local_datahub'), $response['messagecode']);
$this->assertEquals(get_string('ws_program_update_success_msg', 'local_datahub'), $response['message']);
$this->assertInternalType('array', $response['record']);
$this->assertArrayHasKey('id', $response['record']);
// Get Program.
$createdprg = new curriculum($response['record']['id']);
$createdprg->load();
$createdprg = $createdprg->to_array();
foreach ($program as $param => $val) {
$this->assertArrayHasKey($param, $createdprg);
$this->assertEquals($val, $createdprg[$param]);
}
}
/**
* Test successful user creation.
*/
public function test_success()
{
global $DB;
// Create custom field.
$fieldcat = new field_category();
$fieldcat->name = 'Test';
$fieldcat->save();
$field = new field();
$field->categoryid = $fieldcat->id;
$field->shortname = 'testfield';
$field->name = 'Test Field';
$field->datatype = 'text';
$field->save();
$fieldctx = new field_contextlevel();
$fieldctx->fieldid = $field->id;
$fieldctx->contextlevel = CONTEXT_ELIS_USER;
$fieldctx->save();
$user = array('idnumber' => 'testuser', 'username' => 'testuser', 'firstname' => 'testuser', 'lastname' => 'testuser', 'email' => '*****@*****.**', 'country' => 'CA', 'field_testfield' => 'Test Field');
$tempuser = new user();
$tempuser->reset_custom_field_list();
$this->give_permissions(array('local/elisprogram:user_create'));
$response = local_datahub_elis_user_create::user_create($user);
$this->assertNotEmpty($response);
$this->assertInternalType('array', $response);
$this->assertArrayHasKey('messagecode', $response);
$this->assertArrayHasKey('message', $response);
$this->assertArrayHasKey('record', $response);
$this->assertEquals(get_string('ws_user_create_success_code', 'local_datahub'), $response['messagecode']);
$this->assertEquals(get_string('ws_user_create_success_msg', 'local_datahub'), $response['message']);
$this->assertInternalType('array', $response['record']);
$this->assertArrayHasKey('id', $response['record']);
// Get user.
$createduser = new user($response['record']['id']);
$createduser->load();
$createduser = $createduser->to_array();
foreach ($user as $param => $val) {
$this->assertArrayHasKey($param, $createduser);
$this->assertEquals($val, $createduser[$param]);
}
}
/**
* Create the test custom profile field, category and owner
*
* @param string $contextlevelname The name of the custom context level to create the field at
* @param string $datatype The string identifier of the data type to use
* @param string $uitype The string identifier of the UI / control type to use
* @param boolean $multivalued Set to true to make field multivalued, otherwise false
* @param mixed $options Array of menu options, or null for none
* @param int $maxlength The maximum data length, or null for none
* @return int The id of the created field
*/
private function create_test_field($contextlevelname, $datatype, $uitype, $multivalued, $options, $maxlength, $inctime)
{
global $CFG;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elis::lib('data/customfield.class.php');
// Category.
$fieldcategory = new field_category(array('name' => 'testcategoryname'));
$fieldcategory->save();
// Category contextlevel.
$contextlevel = \local_eliscore\context\helper::get_level_from_name($contextlevelname);
$fieldcategorycontextlevel = new field_category_contextlevel(array('categoryid' => $fieldcategory->id, 'contextlevel' => $contextlevel));
$fieldcategorycontextlevel->save();
// Field.
$field = new field(array('shortname' => 'testfieldshortname', 'name' => 'testfieldname', 'categoryid' => $fieldcategory->id, 'datatype' => $datatype));
if ($multivalued) {
// Enable multivalued ability.
$field->multivalued = true;
}
$field->save();
// Field contextlevel.
$fieldcontextlevel = new field_contextlevel(array('fieldid' => $field->id, 'contextlevel' => $contextlevel));
$fieldcontextlevel->save();
// Field owner.
$ownerdata = array('control' => $uitype);
if ($options !== null) {
// Set options.
$ownerdata['options'] = implode("\n", $options);
}
if ($maxlength !== null) {
// Set max length.
$ownerdata['maxlength'] = $maxlength;
}
if ($inctime !== null) {
$ownerdata['inctime'] = $inctime;
}
field_owner::ensure_field_owner_exists($field, 'manual', $ownerdata);
return $field->id;
}
function definition()
{
$form =& $this->_form;
$form->addElement('hidden', 'id');
$form->setType('id', PARAM_INT);
// common form elements (copied from /user/profile/definelib.php)
$form->addElement('header', '_commonsettings', get_string('profilecommonsettings', 'admin'));
$strrequired = get_string('required');
$form->addElement('text', 'shortname', get_string('profileshortname', 'admin'), 'maxlength="100" size="25"');
$form->addRule('shortname', $strrequired, 'required', null, 'client');
$form->setType('shortname', PARAM_SAFEDIR);
$form->addElement('text', 'name', get_string('profilename', 'admin'), 'size="50"');
$form->addRule('name', $strrequired, 'required', null, 'client');
$form->setType('name', PARAM_MULTILANG);
$level = $this->_customdata->required_param('level', PARAM_ACTION);
$ctxlvl = context_level_base::get_custom_context_level($level, 'block_curr_admin');
$categories = field_category::get_for_context_level($ctxlvl);
$choices = array();
foreach ($categories as $category) {
$choices[$category->id] = $category->name;
}
$form->addElement('select', 'categoryid', get_string('profilecategory', 'admin'), $choices);
$form->addElement('htmleditor', 'description', get_string('profiledescription', 'admin'));
$form->setHelpButton('description', array('text', get_string('helptext')));
$choices = array('text' => get_string('field_datatype_text', 'block_curr_admin'), 'char' => get_string('field_datatype_char', 'block_curr_admin'), 'int' => get_string('field_datatype_int', 'block_curr_admin'), 'num' => get_string('field_datatype_num', 'block_curr_admin'), 'bool' => get_string('field_datatype_bool', 'block_curr_admin'));
$form->addElement('select', 'datatype', get_string('field_datatype', 'block_curr_admin'), $choices);
$form->addElement('advcheckbox', 'forceunique', get_string('profileforceunique', 'admin'));
$form->setAdvanced('forceunique');
$form->addElement('advcheckbox', 'multivalued', get_string('field_multivalued', 'block_curr_admin'));
$form->setAdvanced('multivalued');
$form->addElement('text', 'defaultdata', get_string('profiledefaultdata', 'admin'), 'size="50"');
$form->setType('defaultdata', PARAM_MULTILANG);
$plugins = get_list_of_plugins('curriculum/plugins');
foreach ($plugins as $plugin) {
if (is_readable(CURMAN_DIRLOCATION . '/plugins/' . $plugin . '/custom_fields.php')) {
include_once CURMAN_DIRLOCATION . '/plugins/' . $plugin . '/custom_fields.php';
if (function_exists("{$plugin}_field_edit_form_definition")) {
call_user_func("{$plugin}_field_edit_form_definition", $this);
}
}
}
$this->add_action_buttons(true);
}
function definition()
{
$mform =& $this->_form;
/// Add some extra hidden fields
$mform->addElement('hidden', 's', 'field');
$mform->setType('s', PARAM_ACTION);
$mform->addElement('hidden', 'id');
$mform->setType('id', PARAM_INT);
$mform->addElement('hidden', 'action', 'frommoodle');
$mform->setType('action', PARAM_ACTION);
$categories = field_category::get_all();
$choices = array();
foreach ($categories as $category) {
$choices[$category->id] = $category->name;
}
$mform->addElement('select', 'categoryid', get_string('profilecategory', 'admin'), $choices);
$choices = array();
$choices[field::no_sync] = get_string('field_no_sync', 'block_curr_admin');
$choices[field::sync_to_moodle] = get_string('field_sync_to_moodle', 'block_curr_admin');
$choices[field::sync_from_moodle] = get_string('field_sync_from_moodle', 'block_curr_admin');
$mform->addElement('select', 'syncwithmoodle', get_string('field_syncwithmoodle', 'block_curr_admin'), $choices);
$this->add_action_buttons(true);
}
private function create_test_field($name, $datatype, $control, $inctime, $maxlength, $options, $context)
{
$fieldcategory = new field_category(array('name' => 'testcategoryname'));
$fieldcategory->save();
$field = new field(array('shortname' => $name, 'name' => $name, 'datatype' => $datatype, 'categoryid' => $fieldcategory->id));
$field->save();
$ownerdata = array('control' => $control);
if ($options !== null) {
$ownerdata['options'] = implode("\n", $options);
}
if ($maxlength !== null) {
$ownerdata['maxlength'] = $maxlength;
}
if ($inctime !== null) {
$ownerdata['inctime'] = $inctime;
}
// Associate fields to context levels.
$fieldcontextlevel = new field_contextlevel(array('fieldid' => $field->id, 'contextlevel' => $context));
$fieldcontextlevel->save();
field_owner::ensure_field_owner_exists($field, 'manual', $ownerdata);
return $field->id;
}
/**
* Upgrade old ELIS tables.
*
* @param int $oldversion The old ELIS version.
* @return bool Success/Failure.
*/
function local_elisprogram_upgrade_old_tables($oldversion)
{
global $DB, $CFG;
$dbman = $DB->get_manager();
$result = true;
if ($result && $oldversion < 2013031400) {
// ELIS-8066: remove blank/empty menu options from custom field menu/checkbox and defaults using them.
$customfields = $DB->get_recordset('local_eliscore_field', null, '', 'id');
foreach ($customfields as $id => $unused) {
$field = new field($id);
$field->load();
if (isset($field->owners['manual'])) {
$manual = new field_owner($field->owners['manual']);
$control = $manual->param_control;
$options = $manual->param_options;
if (!empty($options) && empty($manual->param_options_source) && ($control == 'menu' || $control == 'checkbox')) {
$options = str_replace("\r", '', $options);
// Strip CRs.
$options = preg_replace("/\n+/", "\n", $options);
$manual->param_options = rtrim($options, "\n");
$manual->save();
// Remove any empty defaults.
$DB->delete_records_select($field->data_table(), "contextid IS NULL AND fieldid = ? AND data = ''", array($id));
}
}
}
upgrade_plugin_savepoint($result, 2013031400, 'elis', 'program');
}
// ELIS-7780: remove deprecated capabilites.
if ($result && $oldversion < 2013041900) {
$capstodelete = array('elis/program:viewgroupreports', 'elis/program:viewreports');
list($inorequal, $params) = $DB->get_in_or_equal($capstodelete);
$where = "capability {$inorequal}";
$DB->delete_records_select('role_capabilities', $where, $params);
$where = "name {$inorequal}";
$DB->delete_records_select('capabilities', $where, $params);
upgrade_plugin_savepoint($result, 2013041900, 'elis', 'program');
}
// Remove any duplicate user track records before attempting to apply an index.
pm_fix_duplicate_usertrack_records('crlm_user_track');
if ($result && $oldversion < 2013042900) {
// Add indexes to {crlm_user_track} table.
$table = new xmldb_table('crlm_user_track');
if ($dbman->table_exists($table)) {
// Array of indexes to drop.
$dropindexes = array(new xmldb_index('any_userid_ix', XMLDB_INDEX_UNIQUE, array('userid')), new xmldb_index('any_trackid_ix', XMLDB_INDEX_UNIQUE, array('trackid')), new xmldb_index('any_userid_trackid_ix', XMLDB_INDEX_NOTUNIQUE, array('userid', 'trackid')));
foreach ($dropindexes as $index) {
// Drop unwanted indexes if they exist.
if ($dbman->index_exists($table, $index)) {
$dbman->drop_index($table, $index);
}
}
// Array of indexes to create.
$createindexes = array(new xmldb_index('userid_ix', XMLDB_INDEX_NOTUNIQUE, array('userid')), new xmldb_index('trackid_ix', XMLDB_INDEX_NOTUNIQUE, array('trackid')), new xmldb_index('userid_trackid_ix', XMLDB_INDEX_UNIQUE, array('userid', 'trackid')));
foreach ($createindexes as $index) {
// Create desired indexes as required.
if (!$dbman->index_exists($table, $index)) {
$dbman->add_index($table, $index);
}
}
}
upgrade_plugin_savepoint($result, 2013042900, 'elis', 'program');
}
if ($result && $oldversion < 2013051500) {
// Change results engine action min/max fields from integer to float.
$table = new xmldb_table('crlm_results_action');
if ($dbman->table_exists($table)) {
$field = new xmldb_field('minimum', XMLDB_TYPE_NUMBER, '10,5', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, null, 'actiontype');
$dbman->change_field_type($table, $field);
$field = new xmldb_field('maximum', XMLDB_TYPE_NUMBER, '10,5', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, null, 'minimum');
$dbman->change_field_type($table, $field);
}
upgrade_plugin_savepoint($result, 2013051500, 'elis', 'program');
}
if ($result && $oldversion < 2013051502) {
// Define table crlm_certificate_settings to be created
// Conditionally launch create table for crlm_certificate_settings.
$table = new xmldb_table('crlm_certificate_settings');
if (!$dbman->table_exists($table)) {
// Adding fields to table crlm_certificate_settings.
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
$table->add_field('entity_id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, null);
$table->add_field('entity_type', XMLDB_TYPE_CHAR, '9', null, XMLDB_NOTNULL, null, null);
$table->add_field('cert_border', XMLDB_TYPE_CHAR, '200', null, XMLDB_NOTNULL, null, null);
$table->add_field('cert_seal', XMLDB_TYPE_CHAR, '200', null, XMLDB_NOTNULL, null, null);
$table->add_field('cert_template', XMLDB_TYPE_CHAR, '200', null, XMLDB_NOTNULL, null, null);
$table->add_field('disable', XMLDB_TYPE_INTEGER, '1', null, XMLDB_NOTNULL, null, '1');
$table->add_field('timecreated', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
$table->add_field('timemodified', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
// Adding keys to table crlm_certificate_settings.
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
// Adding indexes to table crlm_certificate_settings.
$table->add_index('ent_id_type_ix', XMLDB_INDEX_UNIQUE, array('entity_id', 'entity_type'));
$dbman->create_table($table);
}
// Define table crlm_certificate_issued to be created.
$table = new xmldb_table('crlm_certificate_issued');
// Conditionally launch create table for crlm_certificate_issued.
if (!$dbman->table_exists($table)) {
// Adding fields to table crlm_certificate_issued.
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
$table->add_field('cm_userid', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, null);
$table->add_field('cert_setting_id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, null);
$table->add_field('cert_code', XMLDB_TYPE_CHAR, '40', null, XMLDB_NOTNULL, null, null);
$table->add_field('timeissued', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
$table->add_field('timecreated', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
// Adding keys to table crlm_certificate_issued.
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
// Adding indexes to table crlm_certificate_issued.
$table->add_index('cert_code_ix', XMLDB_INDEX_UNIQUE, array('cert_code'));
$table->add_index('cm_userid_ix', XMLDB_INDEX_NOTUNIQUE, array('cm_userid'));
$dbman->create_table($table);
}
// ELIS savepoint reached.
upgrade_plugin_savepoint($result, 2013051502, 'elis', 'program');
}
// ELIS-8528: remove orphaned LOs.
if ($result && $oldversion < 2013051503) {
$where = 'NOT EXISTS (SELECT \'x\' FROM {crlm_course} cc WHERE cc.id = {crlm_course_completion}.courseid)';
$DB->delete_records_select('crlm_course_completion', $where);
upgrade_plugin_savepoint($result, 2013051503, 'elis', 'program');
}
if ($result && $oldversion < 2013082100) {
// Change password field length to 255.
$table = new xmldb_table('crlm_user');
$field = new xmldb_field('password', XMLDB_TYPE_CHAR, '255', null, null, null, null, 'username');
$dbman->change_field_precision($table, $field);
upgrade_plugin_savepoint($result, 2013082100, 'elis', 'program');
}
if ($result && $oldversion < 2013082101) {
require_once elis::file('eliscore/fields/manual/custom_fields.php');
require_once elis::file('eliscore/fields/moodleprofile/custom_fields.php');
$fieldcat = field_category::ensure_exists_for_contextlevel(get_string('moodlefields', 'local_elisprogram'), CONTEXT_ELIS_USER);
$sql = 'SELECT m.id
FROM {user_info_field} m
WHERE NOT EXISTS(
SELECT *
FROM {local_eliscore_field} e
WHERE e.shortname = m.shortname
)';
$fieldstosync = $DB->get_records_sql($sql);
foreach ($fieldstosync as $mfield) {
// Create field.
$efield = field::make_from_moodle_field($mfield->id, $fieldcat, pm_moodle_profile::sync_from_moodle);
// Sync profile field information from Moodle into ELIS.
sync_profile_field_from_moodle($efield);
}
upgrade_plugin_savepoint($result, 2013082101, 'elis', 'program');
}
if ($result && $oldversion < 2013082103) {
// ELIS-8441 & ELIS-8569: Fix Program timetocomplete & frequency defaults of '0y'.
$table = new xmldb_table('crlm_curriculum');
if ($dbman->table_exists($table)) {
$field = new xmldb_field('timetocomplete', XMLDB_TYPE_CHAR, '64', null, XMLDB_NOTNULL, null, null, 'timemodified');
$dbman->change_field_default($table, $field);
$field = new xmldb_field('frequency', XMLDB_TYPE_CHAR, '64', null, XMLDB_NOTNULL, null, null, 'timetocomplete');
$dbman->change_field_default($table, $field);
$sql = 'UPDATE {crlm_curriculum} SET timetocomplete = "" WHERE timetocomplete = "0y"';
$DB->execute($sql);
$sql = 'UPDATE {crlm_curriculum} SET frequency = "" WHERE frequency = "0y"';
$DB->execute($sql);
}
upgrade_plugin_savepoint($result, 2013082103, 'elis', 'program');
}
if ($result && $oldversion < 2013082104) {
require_once dirname(__FILE__) . '/../../../lib/lib.php';
pm_set_config('notify_addedtowaitlist_user', 1);
pm_set_config('notify_enroledfromwaitlist_user', 1);
pm_set_config('notify_incompletecourse_user', 1);
upgrade_plugin_savepoint($result, 2013082104, 'elis', 'program');
}
return $result;
}
/**
* Helper method for creating a custom field
*
* @param int $contextlevel The context level for which to create the field
* @param string $uitype The input control / UI type
* @param array $otherparams Other parameters to give to the field owner
*/
private function create_custom_field($contextlevel, $uitype, $otherparams)
{
global $CFG;
require_once $CFG->dirroot . '/local/eliscore/lib/data/customfield.class.php';
// Category.
$fieldcategory = new field_category(array('name' => 'testcategoryname'));
$fieldcategory->save();
// Field.
$field = new field(array('categoryid' => $fieldcategory->id, 'shortname' => 'testfieldshortname', 'name' => 'testfieldname', 'datatype' => 'text'));
$field->save();
// Field-contextlevel.
$fieldcontextlevel = new field_contextlevel(array('fieldid' => $field->id, 'contextlevel' => $contextlevel));
$fieldcontextlevel->save();
// Owner.
$ownerparams = array_merge(array('control' => $uitype), $otherparams);
field_owner::ensure_field_owner_exists($field, 'manual', $ownerparams);
}
/**
* Create a test custom field category.
* @return field_category The test category.
*/
protected function create_field_category($context)
{
$data = new stdClass();
$data->name = \local_eliscore\context\helper::get_class_for_level($context) . ' Test';
$category = new field_category($data);
$category->save();
$categorycontext = new field_category_contextlevel();
$categorycontext->categoryid = $category->id;
$categorycontext->contextlevel = $context;
$categorycontext->save();
return $category;
}
function display_deletecategory()
{
global $OUTPUT;
$id = $this->required_param('id', PARAM_INT);
$level = $this->required_param('level', PARAM_ACTION);
$category = new field_category($id);
if (!$category->id) {
print_error('invalid_category_id', 'local_elisprogram');
}
$confirm = $this->optional_param('confirm', 0, PARAM_INT);
if ($confirm) {
//load the fields into memory since the record is about to be deleted
$category->load();
$category->delete();
$tmppage = new customfieldpage(array('level' => $level));
redirect($tmppage->url, get_string('field_category_deleted', 'local_elisprogram', $category->name));
} else {
$optionsyes = array('s' => $this->pagename, 'action' => 'deletecategory', 'id' => $id, 'confirm' => 1, 'level' => $level);
$optionsno = array('s' => $this->pagename, 'level' => $level);
$buttoncontinue = new single_button(new moodle_url('index.php', $optionsyes), get_string('yes'), 'POST');
$buttoncancel = new single_button(new moodle_url('index.php', $optionsno), get_string('no'), 'GET');
echo $OUTPUT->confirm(get_string('confirm_delete_category', 'local_elisprogram', $category->name), $buttoncontinue, $buttoncancel);
}
}
/**
* Ensure a category exists with a given name for a given contextlevel.
* @param string $name The name of the category.
* @param int $contextlevel The contextlevel.
* @return field_category Either the existing or the new field_category object.
*/
public static function ensure_exists_for_contextlevel($name, $contextlevel)
{
if (empty($name)) {
return null;
}
if (empty($contextlevel) || !is_int($contextlevel)) {
return null;
}
global $DB;
$sql = 'SELECT cat.id
FROM {' . static::TABLE . '} cat
JOIN {' . field_category_contextlevel::TABLE . '} catctx ON cat.id = catctx.categoryid
WHERE cat.name = ?
AND catctx.contextlevel = ?';
$existingcat = $DB->get_records_sql($sql, array($name, $contextlevel));
if (!empty($existingcat)) {
$existingcat = current($existingcat);
$category = new field_category($existingcat->id);
$category->load();
return $category;
} else {
$category = new field_category();
$category->name = $name;
$category->save();
$catctx = new field_category_contextlevel();
$catctx->categoryid = $category->id;
$catctx->contextlevel = $contextlevel;
$catctx->save();
return $category;
}
}
/**
* Set up data that is needed for testing
*
* @param boolean $setcustomfielddata Specify whether the userset's custom fields should be set
* @param boolean $assignuser Specify whether the user should be directly assigned to the user set
* @param boolean $setautoassociatefields Specity whether we should set up fields that allow userset autoassociation
*/
private function set_up_required_data($setcustomfielddata = true, $assignuser = true, $setautoassociatefields = false)
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elis::lib('data/customfield.class.php');
require_once elispm::file('accesslib.php');
require_once elispm::file('enrol/userset/moodleprofile/userset_profile.class.php');
require_once elispm::lib('data/clusterassignment.class.php');
require_once elispm::lib('data/user.class.php');
require_once elispm::lib('data/usermoodle.class.php');
require_once elispm::lib('data/userset.class.php');
$fieldcategoryid = $DB->get_field(field_category::TABLE, 'id', array('name' => 'Associated Group'));
$this->assertNotEquals(false, $fieldcategoryid);
$fieldcategory = new field_category($fieldcategoryid);
$fieldcategory->load();
// Set up the test user.
$user = new user(array('idnumber' => 'testuseridnumber', 'username' => 'testuserusername', 'firstname' => 'testuserfirstname', 'lastname' => 'testuserlastname', 'email' => '*****@*****.**', 'country' => 'CA'));
$user->save();
$user->synchronize_moodle_user();
// We need a system-level role assignment.
$roleid = create_role('systemrole', 'systemrole', 'systemrole');
$userid = $DB->get_field('user', 'id', array('username' => 'testuserusername'));
$context = context_system::instance();
role_assign($roleid, $userid, $context->id);
// Set up the userset.
$userset = new userset();
$usersetdata = array('name' => 'testusersetname');
if ($setcustomfielddata) {
$usersetdata['field_userset_group'] = 1;
$usersetdata['field_userset_groupings'] = 1;
}
$userset->set_from_data((object) $usersetdata);
$userset->save();
if ($setautoassociatefields) {
// Set up a file we can use to auto-associate users to a userset.
$field = new field(array('categoryid' => $fieldcategory->id, 'shortname' => 'autoassociate', 'name' => 'autoassociate', 'datatype' => 'bool'));
$field->save();
// Ensure manual field owner exists for syncing.
field_owner::ensure_field_owner_exists($field, 'manual');
$ownerid = $DB->get_field(field_owner::TABLE, 'id', array('fieldid' => $field->id, 'plugin' => 'manual'));
$owner = new field_owner($ownerid);
$owner->param_control = 'checkbox';
$owner->save();
field_owner::ensure_field_owner_exists($field, 'moodle_profile');
$DB->execute("UPDATE {" . field_owner::TABLE . "} SET exclude = ?", array(pm_moodle_profile::sync_to_moodle));
$fieldcontextlevel = new field_contextlevel(array('fieldid' => $field->id, 'contextlevel' => CONTEXT_ELIS_USER));
$fieldcontextlevel->save();
// The associated Moodle user profile field.
require_once $CFG->dirroot . '/user/profile/definelib.php';
require_once $CFG->dirroot . '/user/profile/field/checkbox/define.class.php';
$profiledefinecheckbox = new profile_define_checkbox();
$data = new stdClass();
$data->datatype = 'checkbox';
$data->categoryid = 99999;
$data->shortname = 'autoassociate';
$data->name = 'autoassociate';
$profiledefinecheckbox->define_save($data);
$mfield = $DB->get_record('user_info_field', array('shortname' => 'autoassociate'));
// The "cluster-profile" association.
$usersetprofile = new userset_profile(array('clusterid' => $userset->id, 'fieldid' => $mfield->id, 'value' => 1));
$usersetprofile->save();
}
if ($assignuser) {
// Assign the user to the user set.
$clusterassignment = new clusterassignment(array('clusterid' => $userset->id, 'userid' => $user->id, 'plugin' => 'manual'));
$clusterassignment->save();
}
}
/**
* Makes sure that a custom field (identified by $field->shortname) exists
* for the given context level. If not, it will create a field, putting it
* in the given category (identified by $category->name), creating it if
* necessary.
*
* @param object a field object, specifying the field configuration if a
* new field is created
* @param mixed the context level
* @param object a field_category object, specifying the category
* configuration if a new category is created
* @return object a field object
*/
static function ensure_field_exists_for_context_level($field, $ctx_lvl, $category)
{
if (!is_numeric($ctx_lvl)) {
$ctx_lvl = context_level_base::get_custom_context_level($ctx_lvl, 'block_curr_admin');
}
// see if we need to create a new field
$fields = field::get_for_context_level($ctx_lvl);
if (!empty($fields)) {
foreach ($fields as $f) {
if ($f->shortname === $field->shortname) {
return new field($f);
}
}
}
// No existing field found. See if we need to create a category for it
$categories = field_category::get_for_context_level($ctx_lvl);
$found = false;
if (!empty($categories)) {
foreach ($categories as $c) {
if ($c->name === $category->name) {
$category = $found = $c;
break;
}
}
}
if (!$found) {
// create the category
$category->add();
$categorycontext = new field_category_contextlevel();
$categorycontext->categoryid = $category->id;
$categorycontext->contextlevel = $ctx_lvl;
$categorycontext->add();
}
// create the field
$field->categoryid = $category->id;
$field->add();
$fieldcontext = new field_contextlevel();
$fieldcontext->fieldid = $field->id;
$fieldcontext->contextlevel = $ctx_lvl;
$fieldcontext->add();
return $field;
}
$site = get_site();
$block_id = required_param('instance', PARAM_RAW);
$fieldidlist = optional_param('fieldidlist', null, PARAM_TEXT);
$fieldnamelist = optional_param('fieldnamelist', null, PARAM_TEXT);
// Get custom course fields by context level
$context = context_level_base::get_custom_context_level('course', 'block_curr_admin');
$fields = field::get_for_context_level($context);
$fields = $fields ? $fields : array();
//Unserialize fieldidlist to check against field list
if (isset($fieldidlist)) {
$fieldidlist = @unserialize(base64_decode($fieldidlist));
}
if (isset($fieldnamelist)) {
$fieldnamelist = @unserialize(base64_decode($fieldnamelist));
}
$categories = field_category::get_for_context_level($context);
$categories = $categories ? $categories : array();
// divide the fields into categories
$fieldsbycategory = array();
foreach ($categories as $category) {
$fieldsbycategory[$category->name] = array();
}
foreach ($fields as $field) {
if (is_array($fieldidlist) && in_array($field->id, $fieldidlist)) {
continue;
}
//make sure the current user can access this field in at least one
//course context
$owners = field_owner::get_for_field($field);
if (!block_php_report_field_accessible($owners)) {
continue;
/**
* ELIS-4797: Test Various Custom Field Operations
*/
public function test_customfieldoperations()
{
$contextlevels = \local_eliscore\context\helper::get_legacy_levels();
foreach ($contextlevels as $ctxname => $ctxlvl) {
$category = $this->create_field_category($ctxlvl);
$field = $this->create_field($category, $ctxlvl);
$fieldsfetched = field::get_for_context_level($ctxlvl);
$fieldfound = false;
foreach ($fieldsfetched as $fieldfetched) {
if ($fieldfetched->shortname === $field->shortname) {
$fieldfound = true;
}
}
$this->assertTrue($fieldfound);
$fieldfetched = field::get_for_context_level_with_name($ctxlvl, $field->shortname);
$this->assertEquals($field->shortname, $fieldfetched->shortname);
$fieldfetched = field::ensure_field_exists_for_context_level($field, $ctxlvl, $category);
$this->assertEquals($field->shortname, $fieldfetched->shortname);
$catsfetched = field_category::get_for_context_level($ctxlvl);
$catfound = false;
foreach ($catsfetched as $catfetched) {
if ($catfetched->id == $category->id) {
$catfound = true;
}
}
$this->assertTrue($catfound);
if ($ctxlvl === CONTEXT_ELIS_PROGRAM) {
$cur = $this->create_curriculum();
$fielddata = field_data::get_for_context_and_field(null, $field);
$fielddata = $fielddata->current();
$res = $fielddata->set_for_context_from_datarecord($ctxlvl, $cur);
$this->assertTrue($res);
}
}
}
/**
* Function to move any custom fields with an invalid category
* into a category called Miscellaneous
*
*/
function pm_fix_orphaned_fields()
{
global $DB;
$misc_cat = get_string('misc_category', 'local_elisprogram');
//set up context array
$context_array = \local_eliscore\context\helper::get_all_levels();
foreach ($context_array as $contextlevel => $contextname) {
//find all fields with non existant category assignments
$sql = "SELECT field.id\n FROM {" . field::TABLE . "} field\n JOIN {" . field_contextlevel::TABLE . "} ctx ON ctx.fieldid = field.id AND ctx.contextlevel = ?\n WHERE NOT EXISTS (\n SELECT 'x' FROM {" . field_category::TABLE . "} category\n WHERE category.id = field.categoryid)";
$params = array($contextlevel);
$rs = $DB->get_recordset_sql($sql, $params);
//if any are found - then check if miscellaneous category exists - if not, create it
foreach ($rs as $field) {
$sql = "SELECT category.id\n FROM {" . field_category::TABLE . "} category\n JOIN {" . field_category_contextlevel::TABLE . "} categorycontext\n ON categorycontext.categoryid = category.id\n WHERE categorycontext.contextlevel = ?\n AND category.name = ?";
$params = array($contextlevel, $misc_cat);
$categoryid = $DB->get_field_sql($sql, $params);
//create a miscellaneous category if it doesn't already exist
if (!$categoryid) {
// create an empty category
$category = new field_category(array('name' => $misc_cat));
$category->save();
$categorycontext = new field_category_contextlevel();
$categorycontext->categoryid = $category->id;
$categorycontext->contextlevel = $contextlevel;
$categorycontext->save();
$categoryid = $category->id;
}
$field = new field($field->id);
// set the field category to the Miscellaneous category
$field->categoryid = $categoryid;
$field->save();
}
$rs->close();
}
}
/**
* Validate that custom user fields are synched over to Moodle when PM user is created
* during an import
*/
public function test_user_multi_custom_field_on_user_create()
{
global $CFG, $DB, $USER;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elis::lib('data/customfield.class.php');
require_once elis::file('eliscore/fields/moodleprofile/custom_fields.php');
require_once elispm::file('accesslib.php');
require_once elispm::lib('data/user.class.php');
require_once $CFG->dirroot . '/user/profile/lib.php';
require_once $CFG->dirroot . '/user/profile/definelib.php';
require_once $CFG->dirroot . '/user/profile/field/menu/define.class.php';
$CFG->filterall = true;
$USER = get_admin();
$context = context_user::instance($USER->id);
/*
$filternames = filter_get_all_installed();
ob_start();
var_dump($filternames);
$tmp = ob_get_contents();
ob_end_clean();
error_log("test_user_multi_custom_field_on_user_create: all-filters => {$tmp}");
*/
// Note: >= m25 filter paths no longer prefixed with 'filter/'
filter_set_global_state('multilang', TEXTFILTER_ON);
filter_set_applies_to_strings('multilang', true);
$multilangoption1 = '<span class="multilang" lang="en">Male</span><span class="multilang" lang="pt_br">Masculino</span>' . '<span class="multilang" lang="es">Masculino</span>';
$multilangoption2 = '<span class="multilang" lang="en">Female</span><span class="multilang" lang="pt_br">Feminino</span>' . '<span class="multilang" lang="es">Femenino</span>';
// The associated Moodle user profile field.
$profiledefinemenu = new profile_define_menu();
$data = new stdClass();
$data->datatype = 'menu';
$data->categoryid = 99999;
$data->shortname = 'testfieldgender';
$data->name = 'testfieldgender';
$data->param1 = "{$multilangoption1}\n{$multilangoption2}";
$data->defaultdata = $multilangoption2;
$profiledefinemenu->define_save($data);
// Reset cached custom fields.
$user = new user();
$user->reset_custom_field_list();
// Field category.
$fieldcategory = new field_category(array('name' => 'testcategoryname'));
$fieldcategory->save();
// Custom field.
$field = new field(array('categoryid' => $fieldcategory->id, 'shortname' => 'testfieldgender', 'name' => 'testfieldgender', 'datatype' => 'text', 'multivalued' => 1));
$field->save();
// Field owners
field_owner::ensure_field_owner_exists($field, 'moodle_profile');
$manualowneroptions = array('required' => 0, 'edit_capability' => '', 'view_capability' => '', 'control' => 'menu', 'options' => "{$multilangoption1}\n{$multilangoption2}");
field_owner::ensure_field_owner_exists($field, 'manual', $manualowneroptions);
// Field context level assocation.
$fieldcontextlevel = new field_contextlevel(array('fieldid' => $field->id, 'contextlevel' => CONTEXT_ELIS_USER));
$fieldcontextlevel->save();
// Run the user create action.
$record = new stdClass();
$record->action = 'create';
$record->idnumber = 'testuseridnumber';
$record->username = '******';
$record->firstname = 'testuserfirstname';
$record->lastname = 'testuserlastname';
$record->email = '*****@*****.**';
$record->address = 'testuseraddress';
$record->city = 'testusercity';
$record->country = 'CA';
$record->language = 'en';
$record->testfieldgender = 'Male/Female';
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$importplugin->fslogger = new silent_fslogger(null);
$importplugin->process_record('user', $record, 'bogus');
// Validation.
$userid = $DB->get_field(user::TABLE, 'id', array('username' => 'testuserusername'));
$user = new user($userid);
$user->load();
$user = $user->to_object();
/*
$datars = field_data::get_for_context_and_field(\local_elisprogram\context\user::instance($user->id), 'testfieldgender');
foreach ($datars as $data) {
ob_start();
var_dump($data);
$tmp = ob_get_contents();
ob_end_clean();
error_log("test_user_multi_custom_field_on_user_create: data => {$tmp}");
}
*/
/*
ob_start();
var_dump($user);
$tmp = ob_get_contents();
ob_end_clean();
error_log("test_user_multi_custom_field_on_user_create: user => {$tmp}");
*/
$this->assertEquals(array($multilangoption1, $multilangoption2), $user->field_testfieldgender);
}
