/**
* 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;
}
/**
* Update environments and environment assignments to custom fields and
* custom field data (run as a one-off during the elis program upgrade)
*
* If there are one or more entities (courses, classes) with environments
* assigned to them, a new category and custom field is created, specific to the
* appropriate context level. Then, that custom field is populated for each entity
* that has and environment assigned (custom field is a single-select, where the options
* are all the different environments on the site).
*/
function pm_migrate_environments()
{
global $DB;
require_once elis::lib('data/customfield.class.php');
require_once elispm::lib('data/course.class.php');
require_once elispm::lib('data/pmclass.class.php');
//set up our contextlevel mapping
$contextlevels = array(course::TABLE => 'course', pmclass::TABLE => 'class');
//lookup on all tags
$environment_lookup = $DB->get_records('local_elisprogram_env', null, '', 'id, name');
foreach ($environment_lookup as $id => $environment) {
$environment_lookup[$id] = $environment->name;
}
//go through each contextlevel and look for tags
foreach ($contextlevels as $instancetable => $contextname) {
//calculate the context level integer
$contextlevel = \local_eliscore\context\helper::get_level_from_name($contextname);
//make sure one or more environments are used at the current context level
$select = 'environmentid != 0';
if ($DB->record_exists_select($instancetable, $select)) {
//used to reference the category name
$category = new field_category(array('name' => get_string('misc_category', 'local_elisprogram')));
//make sure our field for storing environments is created
$field = new field(array('shortname' => "_19upgrade_{$contextname}_environment", 'name' => get_string('environment', 'local_elisprogram'), 'datatype' => 'char'));
$field = field::ensure_field_exists_for_context_level($field, $contextlevel, $category);
//determine environment options
$options = array();
if ($records = $DB->get_recordset('local_elisprogram_env', null, 'name', 'DISTINCT name')) {
foreach ($records as $record) {
$options[] = $record->name;
}
}
$options = implode("\n", $options);
//set up our field owner
field_owner::ensure_field_owner_exists($field, 'manual', array('control' => 'menu', 'options' => $options, 'edit_capability' => '', 'view_capability' => ''));
//set up data for all relevant entries
$sql = "SELECT id, environmentid\n FROM {{$instancetable}}\n WHERE environmentid != 0";
if ($records = $DB->get_recordset_sql($sql)) {
foreach ($records as $record) {
$contextlevel = \local_eliscore\context\helper::get_level_from_name($contextname);
$contextclass = \local_eliscore\context\helper::get_class_for_level($contextlevel);
$context = $contextclass::instance($record->id);
$environmentid = $environment_lookup[$record->environmentid];
field_data::set_for_context_and_field($context, $field, $environmentid);
}
}
}
}
}
/**
* Creates a PM custom field data record associated to the entity
*
* @param int $userid The PM user's id
* @param int $fieldid The PM custom field id
* @param string $data The data to set
*/
private function update_data_record($entitytype = 'user', $entity, $field, $data)
{
require_once elispm::lib('data/' . $entitytype . '.class.php');
// Save the value for the custom field for the entity.
$contextlevel = \local_eliscore\context\helper::get_level_from_name($entitytype);
$contextclass = \local_eliscore\context\helper::get_class_for_level($contextlevel);
$context = $contextclass::instance($entity->id);
$classname = 'field_data_' . $field->datatype;
$fielddata = new $classname(array('fieldid' => $field->id));
$result = $fielddata->set_for_context_and_field($context, $field, $data);
return $result;
}
function validate_custom_fields($data, $eliscontext)
{
$errors = array();
$contextlevel = \local_eliscore\context\helper::get_level_from_name($eliscontext);
$fields = field::get_for_context_level($contextlevel);
$fields = $fields ? $fields : array();
if (!empty($data['id'])) {
$contextclass = \local_eliscore\context\helper::get_class_for_level($contextlevel);
$context = $contextclass::instance($data['id']);
$contextid = $context->id;
} else {
$contextid = 0;
}
foreach ($fields as $field) {
$field = new field($field);
$key = "field_{$field->shortname}";
if ($errstr = manual_field_validation(isset($data[$key]) ? $data[$key] : null, $field, $contextid)) {
$errors[$key] = $errstr;
}
//error_log("cmform.class.php::validation(): contextid = {$contextid}, data[{$key}] = {$data[$key]}, errors[$key] = {$errstr}");
}
return $errors;
}
/**
* Fetch the contexts where the user has a given capability. This only works
* with the CM context levels.
*
* Assumes that the user does not have "too many" role assignments. Assumes
* the user has no "prevents"/"prohibits" roles.
*/
static function for_user_with_capability($contextlevel, $capability, $userid = null, $doanything = true)
{
global $USER, $DB;
static $pm_context_parents = array('track' => array('curriculum'), 'course' => array('curriculum'), 'class' => array('course', 'track'), 'user' => array('cluster'));
if ($userid === null) {
$userid = $USER->id;
}
$obj = new pm_context_set();
$obj->contextlevel = $contextlevel;
// if the user has the capability at the system level (or has the
// manage master capability), we can stop here
if (has_capability($capability, context_system::instance(), $userid, $doanything) || has_capability('local/elisprogram:manage', context_system::instance(), $userid, $doanything)) {
$obj->contexts = array('system' => 1);
return $obj;
}
$contexts = array($contextlevel => array());
// find all contexts at the given context level where the user has a direct
// role assignment
$ctxlevel = \local_eliscore\context\helper::get_level_from_name($contextlevel);
$ctxclass = \local_eliscore\context\helper::get_class_for_level($ctxlevel);
$sql = "SELECT c.id, c.instanceid\n FROM {role_assignments} ra\n JOIN {context} c ON ra.contextid = c.id\n WHERE ra.userid = {$userid}\n AND c.contextlevel = " . $ctxlevel;
$possiblecontexts = $DB->get_recordset_sql($sql);
foreach ($possiblecontexts as $c) {
$context = $ctxclass::instance($c->instanceid);
if (has_capability($capability, $context, $userid, $doanything)) {
$contexts[$contextlevel][] = $context->__get('instanceid');
}
}
if (empty($contexts[$contextlevel])) {
unset($contexts[$contextlevel]);
}
// look in the parent contexts
if (isset($pm_context_parents[$contextlevel])) {
foreach ($pm_context_parents[$contextlevel] as $parentlevel) {
$parent = pm_context_set::for_user_with_capability($parentlevel, $capability, $userid, $doanything);
$contexts = array_merge($contexts, $parent->contexts);
}
}
$obj->contexts = $contexts;
return $obj;
}
/**
* Validate that the listing respects the local/elisprogram:track_enrol_userset_user
* capability as long as the appropriate userset and track are associated to
* one another and the target user is in the userset
*/
public function test_availableusersrespectsindirectusersetpermissions()
{
global $DB, $USER;
$this->load_csv_data();
set_config('siteguest', '');
set_config('siteadmins', '');
accesslib_clear_all_caches_for_unit_testing();
// Create a test user to be in the userset.
$usersetmember = new user(array('idnumber' => 'usersetmember', 'username' => 'usersetmember', 'firstname' => 'usersetmember', 'lastname' => 'usersetmember', 'email' => '*****@*****.**', 'country' => 'CA'));
$usersetmember->save();
// Our test userset.
$userset = new userset(array('name' => 'userset'));
$userset->save();
// Assign the test user to the test userset.
$clusterassignment = new clusterassignment(array('userid' => $usersetmember->id, 'clusterid' => $userset->id));
$clusterassignment->save();
// Assign the userset to our track.
$clustertrack = new clustertrack(array('clusterid' => $userset->id, 'trackid' => 1));
$clustertrack->save();
// Set up a db record for the active user for permissions reasons.
// (i.e. so they are not treated as an admin).
$activeuser = new user(array('idnumber' => 'activeuser', 'username' => 'activeuser', 'firstname' => 'activeuser', 'lastname' => 'activeuser', 'email' => '*****@*****.**', 'country' => 'CA'));
$activeuser->save();
// Set up our test role.
$roleid = create_role('testrole', 'testrole', 'testrole');
$syscontext = context_system::instance();
assign_capability('local/elisprogram:track_enrol_userset_user', CAP_ALLOW, $roleid, $syscontext->id);
// Perform the role necessary assignment.
$moodleuser = $DB->get_record('user', array('username' => 'activeuser'));
// Make sure all the contexts are created, so that we can find the children.
$contextclass = \local_eliscore\context\helper::get_class_for_level(CONTEXT_ELIS_USERSET);
$instance = $contextclass::instance($userset->id);
role_assign($roleid, $moodleuser->id, $instance->id);
// Assume the role of the user with the role assignment.
$USER = $moodleuser;
$usersrecset = usertrack::get_available_users(1);
$users = array();
foreach ($usersrecset as $key => $user) {
$users[$key] = $user;
}
unset($usersrecset);
$this->assertEquals(1, count($users));
// Validate user.
$this->assertArrayHasKey($usersetmember->id, $users);
$user = $users[$usersetmember->id];
$this->assertEquals($usersetmember->username, 'usersetmember');
// Validate count.
$count = usertrack::count_available_users(1);
$this->assertEquals(1, $count);
}
/**
* 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;
}
/**
* Validate that counting the number of role assignments on a particular
* cluster for a particular role respects special userset permissions
*/
public function test_clusterrolepagecountroleusersrespectsusersetpermissions()
{
global $CFG, $USER, $DB;
require_once elispm::lib('data/clusterassignment.class.php');
require_once elispm::lib('data/user.class.php');
require_once elispm::lib('data/userset.class.php');
accesslib_clear_all_caches(true);
// Create a user record so that Moodle and PM ids don't match by fluke.
set_config('auto_assign_user_idnumber', 0, 'local_elisprogram');
elis::$config = new elis_config();
create_user_record('bogususer', 'Bogususer!0');
// Create our test userset.
$userset = new userset(array('name' => 'testuserset'));
$userset->save();
// The user who is assigned to the user set.
$assigneduser = new user(array('idnumber' => 'assigned', 'username' => 'assigned', 'firstname' => 'assigned', 'lastname' => 'assigned', 'email' => '*****@*****.**', 'country' => 'CA'));
$assigneduser->save();
// Userset assignment.
$clusterassignment = new clusterassignment(array('clusterid' => $userset->id, 'userid' => $assigneduser->id));
$clusterassignment->save();
// User who is potentially assigning the userset member a new role within the userset.
$assigninguser = new user(array('idnumber' => 'assigning', 'username' => 'assigning', 'firstname' => 'assigning', 'lastname' => 'assigning', 'email' => '*****@*****.**', 'country' => 'CA'));
$assigninguser->save();
// Need the system context for role assignments.
$systemcontext = context_system::instance();
// Set up the role that allows a user to assign roles but only to userset members.
$permissionsroleid = create_role('permissionsrole', 'permissionsrole', 'permissionsrole');
// Enable the appropriate capabilities.
assign_capability('moodle/role:assign', CAP_ALLOW, $permissionsroleid, $systemcontext->id);
assign_capability('local/elisprogram:userset_role_assign_userset_users', CAP_ALLOW, $permissionsroleid, $systemcontext->id);
// Perform the role assignment.
$moodleuserid = $DB->get_field('user', 'id', array('username' => 'assigning'));
role_assign($permissionsroleid, $moodleuserid, $systemcontext->id);
// Imitate the user assigned the role which allows for further role assignments only on userset members.
$USER = $DB->get_record('user', array('id' => $moodleuserid));
// Test role for potential assignment to userset members.
$roleid = create_role('targetrole', 'targetrole', 'targetrole');
// Assign the both users to the userset role.
$contextclass = \local_eliscore\context\helper::get_class_for_level(CONTEXT_ELIS_USERSET);
$usersetcontext = $contextclass::instance($userset->id);
role_assign($roleid, $moodleuserid, $usersetcontext->id);
$moodleuserid = $DB->get_field('user', 'id', array('username' => 'assigned'));
role_assign($roleid, $moodleuserid, $usersetcontext->id);
// Obtain the count of assigned users.
$page = new cluster_rolepage(array('id' => $userset->id));
$count = $page->count_role_users($roleid, $usersetcontext);
// List should only contain the userset member.
$this->assertEquals(1, $count);
}
/**
* Convenience function for use by data_object objects
*
* @param mixed $contextlevel the context level. Either a numeric value,
* or the name of the context level from the ELIS Program Manager
* @param object $record the data_object to fetch the field values from
* @return bool true
*/
public static function set_for_context_from_datarecord($contextlevel, $record)
{
if (!is_numeric($contextlevel)) {
$contextlevel = \local_eliscore\context\helper::get_level_from_name($contextlevel);
if (!$contextlevel) {
// context levels not set up -- we must be in initial installation,
// so no fields set up
return true;
}
}
$ctxclass = \local_eliscore\context\helper::get_class_for_level($contextlevel);
$context = $ctxclass::instance($record->id);
$fields = field::get_for_context_level($contextlevel);
$fields = $fields ? $fields : array();
foreach ($fields as $field) {
$fieldname = "field_{$field->shortname}";
if (isset($record->{$fieldname})) {
self::set_for_context_and_field($context, $field, $record->{$fieldname});
}
}
return true;
}
/**
* Get the default repository location.
*
* @uses $CFG, $COURSE, $USER
* @param int $cid A course record ID.
* @param int $uid A user record ID.
* @param bool $shared A flag to indicate whether the user is currently located in the shared repository area.
* @param int $oid A userset record ID.
* @return string The UUID of the last location the user was browsing files in.
*/
function get_default_browsing_location(&$cid, &$uid, &$shared, &$oid) {
global $CFG, $COURSE, $USER, $DB;
// If the default location is not set at all, just return nothing now.
if (!isset($this->config->default_browse)) {
return false;
} elseif (isset($this->config->default_browse)) {
// Handle determining if the user can actually access the chosen default location.
if (empty($cid)) {
$cid = $COURSE->id;
}
$syscontext = context_system::instance();
if ($cid == SITEID) {
$context = $syscontext;
} else {
$context = context_course::instance($cid);
}
/* **** Disable following block for ELIS-7127 ****
// If on ELIS Files page or in course context - default to course page if we have access to it
if ($cid != SITEID && (has_capability('repository/elisfiles:viewcoursecontent', $context) ||
has_capability('repository/elisfiles:createcoursecontent', $context))) {
$shared = 0;
$uid = 0;
return $this->get_course_store($cid);
} else if ($cid == SITEID && $uid == 0 && (has_capability('repository/elisfiles:viewsitecontent', $context) ||
has_capability('repository/elisfiles:createsitecontent', $context))) {
// If on home page and not in user context - default to Company Home if we have access to it
$root = $this->get_root();
if (!empty($root->uuid)) {
$shared = 0;
$uid = 0;
return $root->uuid;
}
}
**** END Disable block for ELIS-7127 **** */
$oid = 0;
/**
* ELIS-7452: We're gonna go thru all possible browing locations
* in pre-determined order:
* User > Site > Shared [> Userset > Course]
* but we'll put desired default_browsing location first!
*/
$browsing_locs = array(ELIS_FILES_BROWSE_USER_FILES,
ELIS_FILES_BROWSE_SITE_FILES,
ELIS_FILES_BROWSE_SHARED_FILES,
ELIS_FILES_BROWSE_COURSE_FILES,
ELIS_FILES_BROWSE_USERSET_FILES);
$default_entry = array_search($this->config->default_browse,
$browsing_locs);
if ($default_entry !== false) {
array_splice($browsing_locs, $default_entry, 1);
}
$browsing_locs = array_merge(array($this->config->default_browse),
$browsing_locs);
// If a user does not have permission to access the default location, fall through to the next
// lower level to see if they can access that location.
// TBD: MUST CHECK FOR CAPABILITIES AY ANY CONTEXT LEVEL!!!
foreach ($browsing_locs as $browse_loc) {
switch ($browse_loc) {
case ELIS_FILES_BROWSE_SITE_FILES:
if (has_capability('repository/elisfiles:viewsitecontent', $syscontext) ||
has_capability('repository/elisfiles:createsitecontent', $syscontext)) {
$root = $this->get_root();
if (!empty($root->uuid)) {
$shared = 0;
$uid = 0;
$cid = 0;
return $root->uuid;
}
}
break;
case ELIS_FILES_BROWSE_SHARED_FILES:
// Get the non context based permissions
$capabilities = array(
'repository/elisfiles:viewsharedcontent' => false,
'repository/elisfiles:createsharedcontent'=> false
);
$this->get_other_capabilities($USER, $capabilities);
$has_permission = $capabilities['repository/elisfiles:viewsharedcontent'] ||
$capabilities['repository/elisfiles:createsharedcontent'] ||
has_capability('repository/elisfiles:viewsitecontent', $syscontext) ||
has_capability('repository/elisfiles:createsitecontent', $syscontext);
if ($has_permission) {
$shared = true;
$uid = 0;
$cid = 0;
return $this->suuid;
}
break;
case ELIS_FILES_BROWSE_COURSE_FILES:
$has_permission = false;
if ($cid == SITEID && $COURSE->id != SITEID) {
$cid = $COURSE->id;
}
if (!$cid || $cid == SITEID) {
// TBD: no valid $COURSE so just find first one???
$courses = enrol_get_my_courses();
if (empty($courses)) {
$cid = 0;
break;
}
foreach ($courses as $course) {
$context = context_course::instance($course->id);
$has_permission = has_capability('repository/elisfiles:viewcoursecontent', $context) ||
has_capability('repository/elisfiles:createcoursecontent', $context) ||
has_capability('repository/elisfiles:viewsitecontent', $syscontext) ||
has_capability('repository/elisfiles:createsitecontent', $syscontext);
if ($has_permission) {
$cid = $course->id;
break;
}
}
}
if ($cid && $cid != SITEID) {
if (!$has_permission) {
$context = context_course::instance($cid);
$has_permission = has_capability('repository/elisfiles:viewcoursecontent', $context) ||
has_capability('repository/elisfiles:createcoursecontent', $context) ||
has_capability('repository/elisfiles:viewsitecontent', $syscontext) ||
has_capability('repository/elisfiles:createsitecontent', $syscontext);
}
if ($has_permission) {
$shared = 0;
$uid = 0;
return $this->get_course_store($cid);
}
}
$cid = 0;
break;
case ELIS_FILES_BROWSE_USER_FILES:
$context = context_user::instance($USER->id);
$has_permission = has_capability('repository/elisfiles:viewowncontent', $syscontext) ||
has_capability('repository/elisfiles:createowncontent', $syscontext) ||
has_capability('repository/elisfiles:viewowncontent', $context) ||
has_capability('repository/elisfiles:createowncontent', $context) ||
has_capability('repository/elisfiles:viewsitecontent', $syscontext) ||
has_capability('repository/elisfiles:createsitecontent', $syscontext);
if ($has_permission) {
if (empty($this->uuuid)) {
$this->uuuid = $this->elis_files_userdir($USER->username);
}
if (($uuid = $this->uuuid) !== false) {
$shared = 0;
$uid = $USER->id;
$cid = 0;
return $uuid;
}
}
break;
case ELIS_FILES_BROWSE_USERSET_FILES:
if (!file_exists($CFG->dirroot.'/local/elisprogram/accesslib.php')) {
break;
}
require_once($CFG->dirroot.'/local/elisprogram/accesslib.php');
require_once($CFG->dirroot.'/local/elisprogram/lib/setup.php');
require_once($CFG->dirroot.'/local/elisprogram/lib/deprecatedlib.php');
$crlm_user = cm_get_crlmuserid($USER->id);
if ($crlm_user === false) {
break;
}
$contextclass = \local_eliscore\context\helper::get_class_for_level(CONTEXT_ELIS_USERSET);
$assignments = $DB->get_records('local_elisprogram_uset_asign',
array('userid' => $crlm_user));
// TBD: just get the first valid userset store???
foreach ($assignments as $cluster_assignment) {
$context = $contextclass::instance($cluster_assignment->clusterid);
$has_permission = has_capability('repository/elisfiles:viewusersetcontent', $context) ||
has_capability('repository/elisfiles:createusersetcontent', $context) ||
has_capability('repository/elisfiles:viewsitecontent', $syscontext) ||
has_capability('repository/elisfiles:createsitecontent', $syscontext);
if ($has_permission) {
$uuid = $this->get_userset_store($cluster_assignment->clusterid);
if (!empty($uuid)) {
$oid = $cluster_assignment->clusterid;
$shared = 0;
$uid = 0;
$cid = 0;
return $uuid;
}
}
}
break;
}
}
}
return false;
}
/**
* Create an ELIS custom field.
* @param field_category &$cat The category to create the field in.
* @param int $context The context level constant to create the category for (ex. CONTEXT_ELIS_USER)
* @return field The created field.
*/
protected function create_field(field_category &$cat, $context)
{
$data = new stdClass();
$data->shortname = \local_eliscore\context\helper::get_class_for_level($context) . '_testfield';
$data->name = ' Test Field';
$data->categoryid = $cat->id;
$data->description = 'Test Field';
$data->datatype = 'text';
$data->forceunique = '0';
$data->mform_showadvanced_last = 0;
$data->multivalued = '0';
$data->defaultdata = '';
$data->manual_field_enabled = '1';
$data->manual_field_edit_capability = '';
$data->manual_field_view_capability = '';
$data->manual_field_control = 'text';
$data->manual_field_options_source = '';
$data->manual_field_options = '';
$data->manual_field_columns = 30;
$data->manual_field_rows = 10;
$data->manual_field_maxlength = 2048;
$field = new field($data);
$field->save();
$fieldcontext = new field_contextlevel();
$fieldcontext->fieldid = $field->id;
$fieldcontext->contextlevel = $context;
$fieldcontext->save();
$owner = new field_owner();
$owner->fieldid = $field->id;
$owner->plugin = 'manual';
$owner->params = serialize(array('required' => false, 'edit_capability' => '', 'view_capability' => '', 'control' => 'text', 'columns' => 30, 'rows' => 10, 'maxlength' => 2048, 'startyear' => '1970', 'stopyear' => '2038', 'inctime' => '0'));
$owner->save();
return $field;
}
/**
* Test that you can delete and promote user subsets
*/
public function test_deletingrecordcanpromoteusersubsets()
{
$this->load_csv_data();
accesslib_clear_all_caches(true);
// Make sure all the contexts are created, so that we can find the children.
$contextclass = \local_eliscore\context\helper::get_class_for_level(CONTEXT_ELIS_USERSET);
for ($i = 1; $i <= 4; $i++) {
$clustercontextinstance = $contextclass::instance($i);
}
// Delete a record.
$src = new userset(2, null, array(), false, array());
$src->deletesubs = false;
$src->delete();
// Read it back.
$result = new moodle_recordset_phpunit_datatable(userset::TABLE, userset::find(null, array(), 0, 0));
$dataset = new PHPUnit_Extensions_Database_DataSet_CsvDataSet();
$dataset->addTable(userset::TABLE, elispm::file('tests/fixtures/userset_promote_test_result.csv'));
$this->assertTablesEqual($dataset->getTable(userset::TABLE), $result);
}
/**
* Ensure that the context is loaded for this record.
*/
private function _load_context()
{
if (!isset($this->_context) && isset($this->id)) {
$ctxclass = \local_eliscore\context\helper::get_class_for_level($this->get_field_context_level());
$this->_context = $ctxclass::instance($this->id);
}
}
/**
* Validate multi-valued custom field data update removes previous selection
*
* @dataProvider entity_type_provider
* @param string $entitytype The type of entity we are running the import for
* @param array $record The inport record to process
* @param string $contextlevelname The name used to refer to the appropriate context level
* @param string $fileidentifier The entity type represented by the input file
* @param mixed $parententitytype The parent entity type, or null if none
* @param mixed $parentrecord The parent data record, or null if none
* @param mixed $parentreffield The field used to refer to the parent element, or null if none
* @param mixed $ipparentreffield The field used to refer to the parent element in IP, or null if none
*/
public function test_multivalue_field_data_update_overwrites_previous_selection($entitytype, $record, $contextlevelname, $fileidentifier, $parententitytype = null, $parentrecord = null, $parentreffield = null, $ipparentreffield = null)
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elis::lib('data/customfield.class.php');
require_once elispm::lib('data/' . $entitytype . '.class.php');
// Set up the custom field, category, context association, and owner.
$fieldid = $this->create_test_field($contextlevelname, 'int', 'menu', true, array('1', '2', '3', '4'), null, null);
// Create parent entity if needed.
if ($parentid = $this->create_parent_entity($parententitytype, $parentrecord, $parentreffield)) {
$record[$parentreffield] = $parentid;
}
// Persist the entity.
$entity = new $entitytype();
$entity->set_from_data((object) array_merge($record, array('field_testfieldshortname' => array('4'))));
$entity->save();
$contextlevel = \local_eliscore\context\helper::get_level_from_name($contextlevelname);
$contextlevel = \local_eliscore\context\helper::get_class_for_level($contextlevel);
$instance = $contextlevel::instance($entity->id);
// Validate setup.
$this->assertEquals(1, $DB->count_records(field_data_int::TABLE));
$this->assertTrue($DB->record_exists(field_data_int::TABLE, array('fieldid' => $fieldid, 'contextid' => $instance->id, 'data' => '4')));
$record['action'] = 'update';
$record['testfieldshortname'] = '1/2/3';
// Run the entity update action.
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$importplugin->fslogger = new silent_fslogger(null);
$importplugin->process_record($fileidentifier, (object) $record, 'bogus');
// Validation.
$this->assert_field_values($contextlevelname, $entitytype::TABLE, field_data_int::TABLE, $fieldid, array('1', '2', '3'));
}
/**
* Perform the necessary actions required to "delete" a cluster from the system.
*
* @param none
* @return bool True on success, False otherwise.
*/
function delete()
{
require_once elis::lib('data/data_filter.class.php');
if ($this->deletesimple) {
//core delete method, not including recursion (entered once for each
//individual userset being delete)
//clean make the delete cascade into association records
$filter = new field_filter('clusterid', $this->id);
clustercurriculum::delete_records($filter, $this->_db);
clustertrack::delete_records($filter, $this->_db);
clusterassignment::delete_records($filter, $this->_db);
//cluster plugin cleanup
$plugins = get_plugin_list(self::ENROL_PLUGIN_TYPE);
foreach ($plugins as $plugin => $plugindir) {
require_once elis::plugin_file(self::ENROL_PLUGIN_TYPE . '_' . $plugin, 'lib.php');
call_user_func('cluster_' . $plugin . '_delete_for_cluster', $this->id);
}
//delete the userset record
parent::delete();
//delete this cluster's context
//get a new context instance,
$contextclass = \local_eliscore\context\helper::get_class_for_level(CONTEXT_ELIS_USERSET);
$userset_context = $contextclass::instance($this->id);
$userset_context->delete();
events_trigger('cluster_deleted', $this->id);
return;
}
$result = true;
$children = array();
$delete_ids = array();
$promote_ids = array();
/// Figure out all the sub-clusters
$cluster_context_instance = \local_elisprogram\context\userset::instance($this->id);
$instance_id = $cluster_context_instance->id;
$instance_path = $cluster_context_instance->path;
$children = userset::find(new join_filter('id', 'context', 'instanceid', new AND_filter(array(new field_filter('path', "{$instance_path}/%", field_filter::LIKE), new field_filter('contextlevel', CONTEXT_ELIS_USERSET)))), array('depth' => 'ASC'), 0, 0, $this->_db);
$children = $children->to_array();
if ($this->deletesubs) {
$todelete = $children;
$todelete[] = $this;
// The specified cluster always gets deleted
} else {
$todelete = array($this);
}
foreach ($todelete as $userset) {
//delete without recursion
$userset->deletesimple = true;
$userset->delete();
}
if (!$this->deletesubs && !empty($children)) {
foreach ($children as $child) {
$lower_depth = $child->depth - 1;
if (userset::exists(new field_filter('id', $child->parent))) {
/// A parent found so lets lower the depth
$child->depth = 0;
} else {
/// Parent not found so this cluster will be top-level
$child->parent = 0;
$child->depth = 1;
}
$child->save();
$sql = "UPDATE {context}\n SET depth=0, path=NULL\n WHERE contextlevel=? AND instanceid=?";
$this->_db->execute($sql, array(CONTEXT_ELIS_USERSET, $child->id));
}
\local_eliscore\context\helper::build_all_paths(false, array(CONTEXT_ELIS_USERSET));
// Re-build the context table for all sub-clusters
}
return $result;
}
