function validation($data, $files)
{
global $COURSE, $DB, $CFG;
$errors = parent::validation($data, $files);
$mform =& $this->_form;
$errors = array();
if ($mform->elementExists('name')) {
$name = trim($data['name']);
if ($name == '') {
$errors['name'] = get_string('required');
}
}
$grade_item = grade_item::fetch(array('itemtype' => 'mod', 'itemmodule' => $data['modulename'], 'iteminstance' => $data['instance'], 'itemnumber' => 0, 'courseid' => $COURSE->id));
if ($data['coursemodule']) {
$cm = $DB->get_record('course_modules', array('id' => $data['coursemodule']));
} else {
$cm = null;
}
if ($mform->elementExists('cmidnumber')) {
// verify the idnumber
if (!grade_verify_idnumber($data['cmidnumber'], $COURSE->id, $grade_item, $cm)) {
$errors['cmidnumber'] = get_string('idnumbertaken');
}
}
// Ratings: Don't let them select an aggregate type without selecting a scale.
// If the user has selected to use ratings but has not chosen a scale or set max points then the form is
// invalid. If ratings have been selected then the user must select either a scale or max points.
// This matches (horrible) logic in data_preprocessing.
if (isset($data['assessed']) && $data['assessed'] > 0 && empty($data['scale'])) {
$errors['assessed'] = get_string('scaleselectionrequired', 'rating');
}
// Check that the grade pass is a valid number.
$gradepassvalid = false;
if (isset($data['gradepass'])) {
if (unformat_float($data['gradepass'], true) === false) {
$errors['gradepass'] = get_string('err_numeric', 'form');
} else {
$gradepassvalid = true;
}
}
// Grade to pass: ensure that the grade to pass is valid for points and scales.
// If we are working with a scale, convert into a positive number for validation.
if ($gradepassvalid && isset($data['gradepass']) && (!empty($data['grade']) || !empty($data['scale']))) {
$scale = !empty($data['grade']) ? $data['grade'] : $data['scale'];
if ($scale < 0) {
$scalevalues = $DB->get_record('scale', array('id' => -$scale));
$grade = count(explode(',', $scalevalues->scale));
} else {
$grade = $scale;
}
if ($data['gradepass'] > $grade) {
$errors['gradepass'] = get_string('gradepassgreaterthangrade', 'grades', $grade);
}
}
// Completion: Don't let them choose automatic completion without turning
// on some conditions. Ignore this check when completion settings are
// locked, as the options are then disabled.
if (array_key_exists('completion', $data) && $data['completion'] == COMPLETION_TRACKING_AUTOMATIC && !empty($data['completionunlocked'])) {
if (empty($data['completionview']) && empty($data['completionusegrade']) && !$this->completion_rule_enabled($data)) {
$errors['completion'] = get_string('badautocompletion', 'completion');
}
}
// Availability: Check availability field does not have errors.
if (!empty($CFG->enableavailability)) {
\core_availability\frontend::report_validation_errors($data, $errors);
}
return $errors;
}
protected function process_module($data) {
global $CFG, $DB;
$data = (object)$data;
$oldid = $data->id;
$this->task->set_old_moduleversion($data->version);
$data->course = $this->task->get_courseid();
$data->module = $DB->get_field('modules', 'id', array('name' => $data->modulename));
// Map section (first try by course_section mapping match. Useful in course and section restores)
$data->section = $this->get_mappingid('course_section', $data->sectionid);
if (!$data->section) { // mapping failed, try to get section by sectionnumber matching
$params = array(
'course' => $this->get_courseid(),
'section' => $data->sectionnumber);
$data->section = $DB->get_field('course_sections', 'id', $params);
}
if (!$data->section) { // sectionnumber failed, try to get first section in course
$params = array(
'course' => $this->get_courseid());
$data->section = $DB->get_field('course_sections', 'MIN(id)', $params);
}
if (!$data->section) { // no sections in course, create section 0 and 1 and assign module to 1
$sectionrec = array(
'course' => $this->get_courseid(),
'section' => 0);
$DB->insert_record('course_sections', $sectionrec); // section 0
$sectionrec = array(
'course' => $this->get_courseid(),
'section' => 1);
$data->section = $DB->insert_record('course_sections', $sectionrec); // section 1
}
$data->groupingid= $this->get_mappingid('grouping', $data->groupingid); // grouping
if (!$CFG->enablegroupmembersonly) { // observe groupsmemberonly
$data->groupmembersonly = 0;
}
if (!grade_verify_idnumber($data->idnumber, $this->get_courseid())) { // idnumber uniqueness
$data->idnumber = '';
}
if (empty($CFG->enablecompletion)) { // completion
$data->completion = 0;
$data->completiongradeitemnumber = null;
$data->completionview = 0;
$data->completionexpected = 0;
} else {
$data->completionexpected = $this->apply_date_offset($data->completionexpected);
}
if (empty($CFG->enableavailability)) {
$data->availablefrom = 0;
$data->availableuntil = 0;
$data->showavailability = 0;
} else {
$data->availablefrom = $this->apply_date_offset($data->availablefrom);
$data->availableuntil= $this->apply_date_offset($data->availableuntil);
}
$data->instance = 0; // Set to 0 for now, going to create it soon (next step)
// course_module record ready, insert it
$newitemid = $DB->insert_record('course_modules', $data);
// save mapping
$this->set_mapping('course_module', $oldid, $newitemid);
// set the new course_module id in the task
$this->task->set_moduleid($newitemid);
// we can now create the context safely
$ctxid = get_context_instance(CONTEXT_MODULE, $newitemid)->id;
// set the new context id in the task
$this->task->set_contextid($ctxid);
// update sequence field in course_section
if ($sequence = $DB->get_field('course_sections', 'sequence', array('id' => $data->section))) {
$sequence .= ',' . $newitemid;
} else {
$sequence = $newitemid;
}
$DB->set_field('course_sections', 'sequence', $sequence, array('id' => $data->section));
}
/**
* This function creates all the gradebook data from xml
*/
function restore_create_gradebook($restore, $xml_file)
{
global $CFG;
$status = true;
//Check it exists
if (!file_exists($xml_file)) {
return false;
}
// Get info from xml
// info will contain the number of record to process
$info = restore_read_xml_gradebook($restore, $xml_file);
// If we have info, then process
if (empty($info)) {
return $status;
}
if (empty($CFG->disablegradehistory) and isset($info->gradebook_histories) and $info->gradebook_histories == "true") {
$restore_histories = true;
} else {
$restore_histories = false;
}
// make sure top course category exists
$course_category = grade_category::fetch_course_category($restore->course_id);
$course_category->load_grade_item();
// we need to know if all grade items that were backed up are being restored
// if that is not the case, we do not restore grade categories nor gradeitems of category type or course type
// i.e. the aggregated grades of that category
$restoreall = true;
// set to false if any grade_item is not selected/restored or already exist
$importing = !empty($SESSION->restore->importing);
if ($importing) {
$restoreall = false;
} else {
$prev_grade_items = grade_item::fetch_all(array('courseid' => $restore->course_id));
$prev_grade_cats = grade_category::fetch_all(array('courseid' => $restore->course_id));
// if any categories already present, skip restore of categories from backup - course item or category already exist
if (count($prev_grade_items) > 1 or count($prev_grade_cats) > 1) {
$restoreall = false;
}
unset($prev_grade_items);
unset($prev_grade_cats);
if ($restoreall) {
if ($recs = get_records_select("backup_ids", "table_name = 'grade_items' AND backup_code = {$restore->backup_unique_code}", "", "old_id")) {
foreach ($recs as $rec) {
if ($data = backup_getid($restore->backup_unique_code, 'grade_items', $rec->old_id)) {
$info = $data->info;
// do not restore if this grade_item is a mod, and
$itemtype = backup_todb($info['GRADE_ITEM']['#']['ITEMTYPE']['0']['#']);
if ($itemtype == 'mod') {
$olditeminstance = backup_todb($info['GRADE_ITEM']['#']['ITEMINSTANCE']['0']['#']);
$itemmodule = backup_todb($info['GRADE_ITEM']['#']['ITEMMODULE']['0']['#']);
if (empty($restore->mods[$itemmodule]->granular)) {
continue;
} else {
if (!empty($restore->mods[$itemmodule]->instances[$olditeminstance]->restore)) {
continue;
}
}
// at least one activity should not be restored - do not restore categories and manual items at all
$restoreall = false;
break;
}
}
}
}
}
}
// Start ul
if (!defined('RESTORE_SILENTLY')) {
echo '<ul>';
}
// array of restored categories - speedup ;-)
$cached_categories = array();
$outcomes = array();
/// Process letters
$context = get_context_instance(CONTEXT_COURSE, $restore->course_id);
// respect current grade letters if defined
if ($status and $restoreall and !record_exists('grade_letters', 'contextid', $context->id)) {
if (!defined('RESTORE_SILENTLY')) {
echo '<li>' . get_string('gradeletters', 'grades') . '</li>';
}
// Fetch recordset_size records in each iteration
$recs = get_records_select("backup_ids", "table_name = 'grade_letters' AND backup_code = {$restore->backup_unique_code}", "", "old_id");
if ($recs) {
foreach ($recs as $rec) {
// Get the full record from backup_ids
$data = backup_getid($restore->backup_unique_code, 'grade_letters', $rec->old_id);
if ($data) {
$info = $data->info;
$dbrec = new object();
$dbrec->contextid = $context->id;
$dbrec->lowerboundary = backup_todb($info['GRADE_LETTER']['#']['LOWERBOUNDARY']['0']['#']);
$dbrec->letter = backup_todb($info['GRADE_LETTER']['#']['LETTER']['0']['#']);
insert_record('grade_letters', $dbrec);
}
}
}
}
/// Preprocess outcomes - do not store them yet!
if ($status and !$importing and $restoreall) {
if (!defined('RESTORE_SILENTLY')) {
echo '<li>' . get_string('gradeoutcomes', 'grades') . '</li>';
}
$recs = get_records_select("backup_ids", "table_name = 'grade_outcomes' AND backup_code = '{$restore->backup_unique_code}'", "", "old_id");
if ($recs) {
foreach ($recs as $rec) {
//Get the full record from backup_ids
$data = backup_getid($restore->backup_unique_code, 'grade_outcomes', $rec->old_id);
if ($data) {
$info = $data->info;
//first find out if outcome already exists
$shortname = backup_todb($info['GRADE_OUTCOME']['#']['SHORTNAME']['0']['#']);
if ($candidates = get_records_sql("SELECT *\n FROM {$CFG->prefix}grade_outcomes\n WHERE (courseid IS NULL OR courseid = {$restore->course_id})\n AND shortname = '{$shortname}'\n ORDER BY courseid ASC, id ASC")) {
$grade_outcome = reset($candidates);
$outcomes[$rec->old_id] = $grade_outcome;
continue;
}
$dbrec = new object();
if (has_capability('moodle/grade:manageoutcomes', get_context_instance(CONTEXT_SYSTEM))) {
$oldoutcome = backup_todb($info['GRADE_OUTCOME']['#']['COURSEID']['0']['#']);
if (empty($oldoutcome)) {
//site wide
$dbrec->courseid = null;
} else {
//course only
$dbrec->courseid = $restore->course_id;
}
} else {
// no permission to add site outcomes
$dbrec->courseid = $restore->course_id;
}
//Get the fields
$dbrec->shortname = backup_todb($info['GRADE_OUTCOME']['#']['SHORTNAME']['0']['#'], false);
$dbrec->fullname = backup_todb($info['GRADE_OUTCOME']['#']['FULLNAME']['0']['#'], false);
$dbrec->scaleid = backup_todb($info['GRADE_OUTCOME']['#']['SCALEID']['0']['#'], false);
$dbrec->description = backup_todb($info['GRADE_OUTCOME']['#']['DESCRIPTION']['0']['#'], false);
$dbrec->timecreated = backup_todb($info['GRADE_OUTCOME']['#']['TIMECREATED']['0']['#'], false);
$dbrec->timemodified = backup_todb($info['GRADE_OUTCOME']['#']['TIMEMODIFIED']['0']['#'], false);
$dbrec->usermodified = backup_todb($info['GRADE_OUTCOME']['#']['USERMODIFIED']['0']['#'], false);
//Need to recode the scaleid
if ($scale = backup_getid($restore->backup_unique_code, 'scale', $dbrec->scaleid)) {
$dbrec->scaleid = $scale->new_id;
}
//Need to recode the usermodified
if ($modifier = backup_getid($restore->backup_unique_code, 'user', $dbrec->usermodified)) {
$dbrec->usermodified = $modifier->new_id;
}
$grade_outcome = new grade_outcome($dbrec, false);
$outcomes[$rec->old_id] = $grade_outcome;
}
}
}
}
/// Process grade items and grades
if ($status) {
if (!defined('RESTORE_SILENTLY')) {
echo '<li>' . get_string('gradeitems', 'grades') . '</li>';
}
$counter = 0;
//Fetch recordset_size records in each iteration
$recs = get_records_select("backup_ids", "table_name = 'grade_items' AND backup_code = '{$restore->backup_unique_code}'", "id", "old_id");
if ($recs) {
foreach ($recs as $rec) {
//Get the full record from backup_ids
$data = backup_getid($restore->backup_unique_code, 'grade_items', $rec->old_id);
if ($data) {
$info = $data->info;
// first find out if category or normal item
$itemtype = backup_todb($info['GRADE_ITEM']['#']['ITEMTYPE']['0']['#'], false);
if ($itemtype == 'course' or $itemtype == 'category') {
if (!$restoreall or $importing) {
continue;
}
$oldcat = backup_todb($info['GRADE_ITEM']['#']['ITEMINSTANCE']['0']['#'], false);
if (!($cdata = backup_getid($restore->backup_unique_code, 'grade_categories', $oldcat))) {
continue;
}
$cinfo = $cdata->info;
unset($cdata);
if ($itemtype == 'course') {
$course_category->fullname = backup_todb($cinfo['GRADE_CATEGORY']['#']['FULLNAME']['0']['#'], false);
$course_category->aggregation = backup_todb($cinfo['GRADE_CATEGORY']['#']['AGGREGATION']['0']['#'], false);
$course_category->keephigh = backup_todb($cinfo['GRADE_CATEGORY']['#']['KEEPHIGH']['0']['#'], false);
$course_category->droplow = backup_todb($cinfo['GRADE_CATEGORY']['#']['DROPLOW']['0']['#'], false);
$course_category->aggregateonlygraded = backup_todb($cinfo['GRADE_CATEGORY']['#']['AGGREGATEONLYGRADED']['0']['#'], false);
$course_category->aggregateoutcomes = backup_todb($cinfo['GRADE_CATEGORY']['#']['AGGREGATEOUTCOMES']['0']['#'], false);
$course_category->aggregatesubcats = backup_todb($cinfo['GRADE_CATEGORY']['#']['AGGREGATESUBCATS']['0']['#'], false);
$course_category->timecreated = backup_todb($cinfo['GRADE_CATEGORY']['#']['TIMECREATED']['0']['#'], false);
$course_category->update('restore');
$status = backup_putid($restore->backup_unique_code, 'grade_categories', $oldcat, $course_category->id) && $status;
$cached_categories[$oldcat] = $course_category;
$grade_item = $course_category->get_grade_item();
} else {
$oldparent = backup_todb($cinfo['GRADE_CATEGORY']['#']['PARENT']['0']['#'], false);
if (empty($cached_categories[$oldparent])) {
debugging('parent not found ' . $oldparent);
continue;
// parent not found, sorry
}
$grade_category = new grade_category();
$grade_category->courseid = $restore->course_id;
$grade_category->parent = $cached_categories[$oldparent]->id;
$grade_category->fullname = backup_todb($cinfo['GRADE_CATEGORY']['#']['FULLNAME']['0']['#'], false);
$grade_category->aggregation = backup_todb($cinfo['GRADE_CATEGORY']['#']['AGGREGATION']['0']['#'], false);
$grade_category->keephigh = backup_todb($cinfo['GRADE_CATEGORY']['#']['KEEPHIGH']['0']['#'], false);
$grade_category->droplow = backup_todb($cinfo['GRADE_CATEGORY']['#']['DROPLOW']['0']['#'], false);
$grade_category->aggregateonlygraded = backup_todb($cinfo['GRADE_CATEGORY']['#']['AGGREGATEONLYGRADED']['0']['#'], false);
$grade_category->aggregateoutcomes = backup_todb($cinfo['GRADE_CATEGORY']['#']['AGGREGATEOUTCOMES']['0']['#'], false);
$grade_category->aggregatesubcats = backup_todb($cinfo['GRADE_CATEGORY']['#']['AGGREGATESUBCATS']['0']['#'], false);
$grade_category->timecreated = backup_todb($cinfo['GRADE_CATEGORY']['#']['TIMECREATED']['0']['#'], false);
$grade_category->insert('restore');
$status = backup_putid($restore->backup_unique_code, 'grade_categories', $oldcat, $grade_category->id) && $status;
$cached_categories[$oldcat] = $grade_category;
$grade_item = $grade_category->get_grade_item();
// creates grade_item too
}
unset($cinfo);
$idnumber = backup_todb($info['GRADE_ITEM']['#']['IDNUMBER']['0']['#'], false);
if (grade_verify_idnumber($idnumber, $restore->course_id)) {
$grade_item->idnumber = $idnumber;
}
$grade_item->itemname = backup_todb($info['GRADE_ITEM']['#']['ITEMNAME']['0']['#'], false);
$grade_item->iteminfo = backup_todb($info['GRADE_ITEM']['#']['ITEMINFO']['0']['#'], false);
$grade_item->gradetype = backup_todb($info['GRADE_ITEM']['#']['GRADETYPE']['0']['#'], false);
$grade_item->calculation = backup_todb($info['GRADE_ITEM']['#']['CALCULATION']['0']['#'], false);
$grade_item->grademax = backup_todb($info['GRADE_ITEM']['#']['GRADEMAX']['0']['#'], false);
$grade_item->grademin = backup_todb($info['GRADE_ITEM']['#']['GRADEMIN']['0']['#'], false);
$grade_item->gradepass = backup_todb($info['GRADE_ITEM']['#']['GRADEPASS']['0']['#'], false);
$grade_item->multfactor = backup_todb($info['GRADE_ITEM']['#']['MULTFACTOR']['0']['#'], false);
$grade_item->plusfactor = backup_todb($info['GRADE_ITEM']['#']['PLUSFACTOR']['0']['#'], false);
$grade_item->aggregationcoef = backup_todb($info['GRADE_ITEM']['#']['AGGREGATIONCOEF']['0']['#'], false);
$grade_item->display = backup_todb($info['GRADE_ITEM']['#']['DISPLAY']['0']['#'], false);
$grade_item->decimals = backup_todb($info['GRADE_ITEM']['#']['DECIMALS']['0']['#'], false);
$grade_item->hidden = backup_todb($info['GRADE_ITEM']['#']['HIDDEN']['0']['#'], false);
$grade_item->locked = backup_todb($info['GRADE_ITEM']['#']['LOCKED']['0']['#'], false);
$grade_item->locktime = backup_todb($info['GRADE_ITEM']['#']['LOCKTIME']['0']['#'], false);
$grade_item->timecreated = backup_todb($info['GRADE_ITEM']['#']['TIMECREATED']['0']['#'], false);
if (backup_todb($info['GRADE_ITEM']['#']['SCALEID']['0']['#'], false)) {
$scale = backup_getid($restore->backup_unique_code, "scale", backup_todb($info['GRADE_ITEM']['#']['SCALEID']['0']['#'], false));
$grade_item->scaleid = $scale->new_id;
}
if (backup_todb($info['GRADE_ITEM']['#']['OUTCOMEID']['0']['#'], false)) {
$outcome = backup_getid($restore->backup_unique_code, "grade_outcomes", backup_todb($info['GRADE_ITEM']['#']['OUTCOMEID']['0']['#'], false));
$grade_item->outcomeid = $outcome->new_id;
}
$grade_item->update('restore');
$status = backup_putid($restore->backup_unique_code, "grade_items", $rec->old_id, $grade_item->id) && $status;
} else {
if ($itemtype != 'mod' and (!$restoreall or $importing)) {
// not extra gradebook stuff if restoring individual activities or something already there
continue;
}
$dbrec = new object();
$dbrec->courseid = $restore->course_id;
$dbrec->itemtype = backup_todb($info['GRADE_ITEM']['#']['ITEMTYPE']['0']['#'], false);
$dbrec->itemmodule = backup_todb($info['GRADE_ITEM']['#']['ITEMMODULE']['0']['#'], false);
if ($itemtype == 'mod') {
// iteminstance should point to new mod
$olditeminstance = backup_todb($info['GRADE_ITEM']['#']['ITEMINSTANCE']['0']['#'], false);
$mod = backup_getid($restore->backup_unique_code, $dbrec->itemmodule, $olditeminstance);
$dbrec->iteminstance = $mod->new_id;
if (!($cm = get_coursemodule_from_instance($dbrec->itemmodule, $mod->new_id))) {
// item not restored - no item
continue;
}
// keep in sync with activity idnumber
$dbrec->idnumber = $cm->idnumber;
} else {
$idnumber = backup_todb($info['GRADE_ITEM']['#']['IDNUMBER']['0']['#'], false);
if (grade_verify_idnumber($idnumber, $restore->course_id)) {
//make sure the new idnumber is unique
$dbrec->idnumber = $idnumber;
}
}
$dbrec->itemname = backup_todb($info['GRADE_ITEM']['#']['ITEMNAME']['0']['#'], false);
$dbrec->itemtype = backup_todb($info['GRADE_ITEM']['#']['ITEMTYPE']['0']['#'], false);
$dbrec->itemmodule = backup_todb($info['GRADE_ITEM']['#']['ITEMMODULE']['0']['#'], false);
$dbrec->itemnumber = backup_todb($info['GRADE_ITEM']['#']['ITEMNUMBER']['0']['#'], false);
$dbrec->iteminfo = backup_todb($info['GRADE_ITEM']['#']['ITEMINFO']['0']['#'], false);
$dbrec->gradetype = backup_todb($info['GRADE_ITEM']['#']['GRADETYPE']['0']['#'], false);
$dbrec->calculation = backup_todb($info['GRADE_ITEM']['#']['CALCULATION']['0']['#'], false);
$dbrec->grademax = backup_todb($info['GRADE_ITEM']['#']['GRADEMAX']['0']['#'], false);
$dbrec->grademin = backup_todb($info['GRADE_ITEM']['#']['GRADEMIN']['0']['#'], false);
$dbrec->gradepass = backup_todb($info['GRADE_ITEM']['#']['GRADEPASS']['0']['#'], false);
$dbrec->multfactor = backup_todb($info['GRADE_ITEM']['#']['MULTFACTOR']['0']['#'], false);
$dbrec->plusfactor = backup_todb($info['GRADE_ITEM']['#']['PLUSFACTOR']['0']['#'], false);
$dbrec->aggregationcoef = backup_todb($info['GRADE_ITEM']['#']['AGGREGATIONCOEF']['0']['#'], false);
$dbrec->display = backup_todb($info['GRADE_ITEM']['#']['DISPLAY']['0']['#'], false);
$dbrec->decimals = backup_todb($info['GRADE_ITEM']['#']['DECIMALS']['0']['#'], false);
$dbrec->hidden = backup_todb($info['GRADE_ITEM']['#']['HIDDEN']['0']['#'], false);
$dbrec->locked = backup_todb($info['GRADE_ITEM']['#']['LOCKED']['0']['#'], false);
$dbrec->locktime = backup_todb($info['GRADE_ITEM']['#']['LOCKTIME']['0']['#'], false);
$dbrec->timecreated = backup_todb($info['GRADE_ITEM']['#']['TIMECREATED']['0']['#'], false);
if (backup_todb($info['GRADE_ITEM']['#']['SCALEID']['0']['#'], false)) {
$scale = backup_getid($restore->backup_unique_code, "scale", backup_todb($info['GRADE_ITEM']['#']['SCALEID']['0']['#'], false));
$dbrec->scaleid = $scale->new_id;
}
if (backup_todb($info['GRADE_ITEM']['#']['OUTCOMEID']['0']['#'])) {
$oldoutcome = backup_todb($info['GRADE_ITEM']['#']['OUTCOMEID']['0']['#']);
if (empty($outcomes[$oldoutcome])) {
continue;
// error!
}
if (empty($outcomes[$oldoutcome]->id)) {
$outcomes[$oldoutcome]->insert('restore');
$outcomes[$oldoutcome]->use_in($restore->course_id);
backup_putid($restore->backup_unique_code, "grade_outcomes", $oldoutcome, $outcomes[$oldoutcome]->id);
}
$dbrec->outcomeid = $outcomes[$oldoutcome]->id;
}
$grade_item = new grade_item($dbrec, false);
$grade_item->insert('restore');
if ($restoreall) {
// set original parent if restored
$oldcat = $info['GRADE_ITEM']['#']['CATEGORYID']['0']['#'];
if (!empty($cached_categories[$oldcat])) {
$grade_item->set_parent($cached_categories[$oldcat]->id);
}
}
$status = backup_putid($restore->backup_unique_code, "grade_items", $rec->old_id, $grade_item->id) && $status;
}
// no need to restore grades if user data is not selected or importing activities
if ($importing or $grade_item->itemtype == 'mod' and !restore_userdata_selected($restore, $grade_item->itemmodule, $olditeminstance)) {
// module instance not selected when restored using granular
// skip this item
continue;
}
/// now, restore grade_grades
if (!empty($info['GRADE_ITEM']['#']['GRADE_GRADES']['0']['#']['GRADE'])) {
//Iterate over items
foreach ($info['GRADE_ITEM']['#']['GRADE_GRADES']['0']['#']['GRADE'] as $g_info) {
$grade = new grade_grade();
$grade->itemid = $grade_item->id;
$olduser = backup_todb($g_info['#']['USERID']['0']['#'], false);
$user = backup_getid($restore->backup_unique_code, "user", $olduser);
$grade->userid = $user->new_id;
$grade->rawgrade = backup_todb($g_info['#']['RAWGRADE']['0']['#'], false);
$grade->rawgrademax = backup_todb($g_info['#']['RAWGRADEMAX']['0']['#'], false);
$grade->rawgrademin = backup_todb($g_info['#']['RAWGRADEMIN']['0']['#'], false);
// need to find scaleid
if (backup_todb($g_info['#']['RAWSCALEID']['0']['#'])) {
$scale = backup_getid($restore->backup_unique_code, "scale", backup_todb($g_info['#']['RAWSCALEID']['0']['#'], false));
$grade->rawscaleid = $scale->new_id;
}
if (backup_todb($g_info['#']['USERMODIFIED']['0']['#'])) {
if ($modifier = backup_getid($restore->backup_unique_code, "user", backup_todb($g_info['#']['USERMODIFIED']['0']['#'], false))) {
$grade->usermodified = $modifier->new_id;
}
}
$grade->finalgrade = backup_todb($g_info['#']['FINALGRADE']['0']['#'], false);
$grade->hidden = backup_todb($g_info['#']['HIDDEN']['0']['#'], false);
$grade->locked = backup_todb($g_info['#']['LOCKED']['0']['#'], false);
$grade->locktime = backup_todb($g_info['#']['LOCKTIME']['0']['#'], false);
$grade->exported = backup_todb($g_info['#']['EXPORTED']['0']['#'], false);
$grade->overridden = backup_todb($g_info['#']['OVERRIDDEN']['0']['#'], false);
$grade->excluded = backup_todb($g_info['#']['EXCLUDED']['0']['#'], false);
$grade->feedback = backup_todb($g_info['#']['FEEDBACK']['0']['#'], false);
$grade->feedbackformat = backup_todb($g_info['#']['FEEDBACKFORMAT']['0']['#'], false);
$grade->information = backup_todb($g_info['#']['INFORMATION']['0']['#'], false);
$grade->informationformat = backup_todb($g_info['#']['INFORMATIONFORMAT']['0']['#'], false);
$grade->timecreated = backup_todb($g_info['#']['TIMECREATED']['0']['#'], false);
$grade->timemodified = backup_todb($g_info['#']['TIMEMODIFIED']['0']['#'], false);
$grade->insert('restore');
backup_putid($restore->backup_unique_code, "grade_grades", backup_todb($g_info['#']['ID']['0']['#']), $grade->id);
$counter++;
if ($counter % 20 == 0) {
if (!defined('RESTORE_SILENTLY')) {
echo ".";
if ($counter % 400 == 0) {
echo "<br />";
}
}
backup_flush(300);
}
}
}
}
}
}
}
/// add outcomes that are not used when doing full restore
if ($status and $restoreall) {
foreach ($outcomes as $oldoutcome => $grade_outcome) {
if (empty($grade_outcome->id)) {
$grade_outcome->insert('restore');
$grade_outcome->use_in($restore->course_id);
backup_putid($restore->backup_unique_code, "grade_outcomes", $oldoutcome, $grade_outcome->id);
}
}
}
if ($status and !$importing and $restore_histories) {
/// following code is very inefficient
$gchcount = count_records('backup_ids', 'backup_code', $restore->backup_unique_code, 'table_name', 'grade_categories_history');
$gghcount = count_records('backup_ids', 'backup_code', $restore->backup_unique_code, 'table_name', 'grade_grades_history');
$gihcount = count_records('backup_ids', 'backup_code', $restore->backup_unique_code, 'table_name', 'grade_items_history');
$gohcount = count_records('backup_ids', 'backup_code', $restore->backup_unique_code, 'table_name', 'grade_outcomes_history');
// Number of records to get in every chunk
$recordset_size = 2;
// process histories
if ($gchcount && $status) {
if (!defined('RESTORE_SILENTLY')) {
echo '<li>' . get_string('gradecategoryhistory', 'grades') . '</li>';
}
$counter = 0;
while ($counter < $gchcount) {
//Fetch recordset_size records in each iteration
$recs = get_records_select("backup_ids", "table_name = 'grade_categories_history' AND backup_code = '{$restore->backup_unique_code}'", "old_id", "old_id", $counter, $recordset_size);
if ($recs) {
foreach ($recs as $rec) {
//Get the full record from backup_ids
$data = backup_getid($restore->backup_unique_code, 'grade_categories_history', $rec->old_id);
if ($data) {
//Now get completed xmlized object
$info = $data->info;
//traverse_xmlize($info); //Debug
//print_object ($GLOBALS['traverse_array']); //Debug
//$GLOBALS['traverse_array']=""; //Debug
$oldobj = backup_getid($restore->backup_unique_code, "grade_categories", backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['OLDID']['0']['#']));
if (empty($oldobj->new_id)) {
// if the old object is not being restored, can't restoring its history
$counter++;
continue;
}
$dbrec->oldid = $oldobj->new_id;
$dbrec->action = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['ACTION']['0']['#']);
$dbrec->source = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['SOURCE']['0']['#']);
$dbrec->timemodified = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['TIMEMODIFIED']['0']['#']);
// loggeduser might not be restored, e.g. admin
if ($oldobj = backup_getid($restore->backup_unique_code, "user", backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['LOGGEDUSER']['0']['#']))) {
$dbrec->loggeduser = $oldobj->new_id;
}
// this item might not have a parent at all, do not skip it if no parent is specified
if (backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['PARENT']['0']['#'])) {
$oldobj = backup_getid($restore->backup_unique_code, "grade_categories", backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['PARENT']['0']['#']));
if (empty($oldobj->new_id)) {
// if the parent category not restored
$counter++;
continue;
}
}
$dbrec->parent = $oldobj->new_id;
$dbrec->depth = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['DEPTH']['0']['#']);
// path needs to be rebuilt
if ($path = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['PATH']['0']['#'])) {
// to preserve the path and make it work, we need to replace the categories one by one
// we first get the list of categories in current path
if ($paths = explode("/", $path)) {
$newpath = '';
foreach ($paths as $catid) {
if ($catid) {
// find the new corresponding path
$oldpath = backup_getid($restore->backup_unique_code, "grade_categories", $catid);
$newpath .= "/{$oldpath->new_id}";
}
}
$dbrec->path = $newpath;
}
}
$dbrec->fullname = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['FULLNAME']['0']['#']);
$dbrec->aggregation = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['AGGRETGATION']['0']['#']);
$dbrec->keephigh = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['KEEPHIGH']['0']['#']);
$dbrec->droplow = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['DROPLOW']['0']['#']);
$dbrec->aggregateonlygraded = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['AGGREGATEONLYGRADED']['0']['#']);
$dbrec->aggregateoutcomes = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['AGGREGATEOUTCOMES']['0']['#']);
$dbrec->aggregatesubcats = backup_todb($info['GRADE_CATEGORIES_HISTORY']['#']['AGGREGATESUBCATS']['0']['#']);
$dbrec->courseid = $restore->course_id;
insert_record('grade_categories_history', $dbrec);
unset($dbrec);
}
//Increment counters
$counter++;
//Do some output
if ($counter % 1 == 0) {
if (!defined('RESTORE_SILENTLY')) {
echo ".";
if ($counter % 20 == 0) {
echo "<br />";
}
}
backup_flush(300);
}
}
}
}
}
// process histories
if ($gghcount && $status) {
if (!defined('RESTORE_SILENTLY')) {
echo '<li>' . get_string('gradegradeshistory', 'grades') . '</li>';
}
$counter = 0;
while ($counter < $gghcount) {
//Fetch recordset_size records in each iteration
$recs = get_records_select("backup_ids", "table_name = 'grade_grades_history' AND backup_code = '{$restore->backup_unique_code}'", "old_id", "old_id", $counter, $recordset_size);
if ($recs) {
foreach ($recs as $rec) {
//Get the full record from backup_ids
$data = backup_getid($restore->backup_unique_code, 'grade_grades_history', $rec->old_id);
if ($data) {
//Now get completed xmlized object
$info = $data->info;
//traverse_xmlize($info); //Debug
//print_object ($GLOBALS['traverse_array']); //Debug
//$GLOBALS['traverse_array']=""; //Debug
$oldobj = backup_getid($restore->backup_unique_code, "grade_grades", backup_todb($info['GRADE_GRADES_HISTORY']['#']['OLDID']['0']['#']));
if (empty($oldobj->new_id)) {
// if the old object is not being restored, can't restoring its history
$counter++;
continue;
}
$dbrec->oldid = $oldobj->new_id;
$dbrec->action = backup_todb($info['GRADE_GRADES_HISTORY']['#']['ACTION']['0']['#']);
$dbrec->source = backup_todb($info['GRADE_GRADES_HISTORY']['#']['SOURCE']['0']['#']);
$dbrec->timemodified = backup_todb($info['GRADE_GRADES_HISTORY']['#']['TIMEMODIFIED']['0']['#']);
if ($oldobj = backup_getid($restore->backup_unique_code, "user", backup_todb($info['GRADE_GRADES_HISTORY']['#']['LOGGEDUSER']['0']['#']))) {
$dbrec->loggeduser = $oldobj->new_id;
}
$oldobj = backup_getid($restore->backup_unique_code, "grade_items", backup_todb($info['GRADE_GRADES_HISTORY']['#']['ITEMID']['0']['#']));
$dbrec->itemid = $oldobj->new_id;
if (empty($dbrec->itemid)) {
$counter++;
continue;
// grade item not being restored
}
$oldobj = backup_getid($restore->backup_unique_code, "user", backup_todb($info['GRADE_GRADES_HISTORY']['#']['USERID']['0']['#']));
$dbrec->userid = $oldobj->new_id;
$dbrec->rawgrade = backup_todb($info['GRADE_GRADES_HISTORY']['#']['RAWGRADE']['0']['#']);
$dbrec->rawgrademax = backup_todb($info['GRADE_GRADES_HISTORY']['#']['RAWGRADEMAX']['0']['#']);
$dbrec->rawgrademin = backup_todb($info['GRADE_GRADES_HISTORY']['#']['RAWGRADEMIN']['0']['#']);
if ($oldobj = backup_getid($restore->backup_unique_code, "user", backup_todb($info['GRADE_GRADES_HISTORY']['#']['USERMODIFIED']['0']['#']))) {
$dbrec->usermodified = $oldobj->new_id;
}
if (backup_todb($info['GRADE_GRADES_HISTORY']['#']['RAWSCALEID']['0']['#'])) {
$scale = backup_getid($restore->backup_unique_code, "scale", backup_todb($info['GRADE_GRADES_HISTORY']['#']['RAWSCALEID']['0']['#']));
$dbrec->rawscaleid = $scale->new_id;
}
$dbrec->finalgrade = backup_todb($info['GRADE_GRADES_HISTORY']['#']['FINALGRADE']['0']['#']);
$dbrec->hidden = backup_todb($info['GRADE_GRADES_HISTORY']['#']['HIDDEN']['0']['#']);
$dbrec->locked = backup_todb($info['GRADE_GRADES_HISTORY']['#']['LOCKED']['0']['#']);
$dbrec->locktime = backup_todb($info['GRADE_GRADES_HISTORY']['#']['LOCKTIME']['0']['#']);
$dbrec->exported = backup_todb($info['GRADE_GRADES_HISTORY']['#']['EXPORTED']['0']['#']);
$dbrec->overridden = backup_todb($info['GRADE_GRADES_HISTORY']['#']['OVERRIDDEN']['0']['#']);
$dbrec->excluded = backup_todb($info['GRADE_GRADES_HISTORY']['#']['EXCLUDED']['0']['#']);
$dbrec->feedback = backup_todb($info['GRADE_TEXT_HISTORY']['#']['FEEDBACK']['0']['#']);
$dbrec->feedbackformat = backup_todb($info['GRADE_TEXT_HISTORY']['#']['FEEDBACKFORMAT']['0']['#']);
$dbrec->information = backup_todb($info['GRADE_TEXT_HISTORY']['#']['INFORMATION']['0']['#']);
$dbrec->informationformat = backup_todb($info['GRADE_TEXT_HISTORY']['#']['INFORMATIONFORMAT']['0']['#']);
insert_record('grade_grades_history', $dbrec);
unset($dbrec);
}
//Increment counters
$counter++;
//Do some output
if ($counter % 1 == 0) {
if (!defined('RESTORE_SILENTLY')) {
echo ".";
if ($counter % 20 == 0) {
echo "<br />";
}
}
backup_flush(300);
}
}
}
}
}
// process histories
if ($gihcount && $status) {
if (!defined('RESTORE_SILENTLY')) {
echo '<li>' . get_string('gradeitemshistory', 'grades') . '</li>';
}
$counter = 0;
while ($counter < $gihcount) {
//Fetch recordset_size records in each iteration
$recs = get_records_select("backup_ids", "table_name = 'grade_items_history' AND backup_code = '{$restore->backup_unique_code}'", "old_id", "old_id", $counter, $recordset_size);
if ($recs) {
foreach ($recs as $rec) {
//Get the full record from backup_ids
$data = backup_getid($restore->backup_unique_code, 'grade_items_history', $rec->old_id);
if ($data) {
//Now get completed xmlized object
$info = $data->info;
//traverse_xmlize($info); //Debug
//print_object ($GLOBALS['traverse_array']); //Debug
//$GLOBALS['traverse_array']=""; //Debug
$oldobj = backup_getid($restore->backup_unique_code, "grade_items", backup_todb($info['GRADE_ITEM_HISTORY']['#']['OLDID']['0']['#']));
if (empty($oldobj->new_id)) {
// if the old object is not being restored, can't restoring its history
$counter++;
continue;
}
$dbrec->oldid = $oldobj->new_id;
$dbrec->action = backup_todb($info['GRADE_ITEM_HISTORY']['#']['ACTION']['0']['#']);
$dbrec->source = backup_todb($info['GRADE_ITEM_HISTORY']['#']['SOURCE']['0']['#']);
$dbrec->timemodified = backup_todb($info['GRADE_ITEM_HISTORY']['#']['TIMEMODIFIED']['0']['#']);
if ($oldobj = backup_getid($restore->backup_unique_code, "user", backup_todb($info['GRADE_ITEM_HISTORY']['#']['LOGGEDUSER']['0']['#']))) {
$dbrec->loggeduser = $oldobj->new_id;
}
$dbrec->courseid = $restore->course_id;
$oldobj = backup_getid($restore->backup_unique_code, 'grade_categories', backup_todb($info['GRADE_ITEM_HISTORY']['#']['CATEGORYID']['0']['#']));
$oldobj->categoryid = $category->new_id;
if (empty($oldobj->categoryid)) {
$counter++;
continue;
// category not restored
}
$dbrec->itemname = backup_todb($info['GRADE_ITEM_HISTORY']['#']['ITEMNAME']['0']['#']);
$dbrec->itemtype = backup_todb($info['GRADE_ITEM_HISTORY']['#']['ITEMTYPE']['0']['#']);
$dbrec->itemmodule = backup_todb($info['GRADE_ITEM_HISTORY']['#']['ITEMMODULE']['0']['#']);
// code from grade_items restore
$iteminstance = backup_todb($info['GRADE_ITEM_HISTORY']['#']['ITEMINSTANCE']['0']['#']);
// do not restore if this grade_item is a mod, and
if ($dbrec->itemtype == 'mod') {
if (!restore_userdata_selected($restore, $dbrec->itemmodule, $iteminstance)) {
// module instance not selected when restored using granular
// skip this item
$counter++;
continue;
}
// iteminstance should point to new mod
$mod = backup_getid($restore->backup_unique_code, $dbrec->itemmodule, $iteminstance);
$dbrec->iteminstance = $mod->new_id;
} else {
if ($dbrec->itemtype == 'category') {
// the item instance should point to the new grade category
// only proceed if we are restoring all grade items
if ($restoreall) {
$category = backup_getid($restore->backup_unique_code, 'grade_categories', $iteminstance);
$dbrec->iteminstance = $category->new_id;
} else {
// otherwise we can safely ignore this grade item and subsequent
// grade_raws, grade_finals etc
continue;
}
} elseif ($dbrec->itemtype == 'course') {
// We don't restore course type to avoid duplicate course items
if ($restoreall) {
// TODO any special code needed here to restore course item without duplicating it?
// find the course category with depth 1, and course id = current course id
// this would have been already restored
$cat = get_record('grade_categories', 'depth', 1, 'courseid', $restore->course_id);
$dbrec->iteminstance = $cat->id;
} else {
$counter++;
continue;
}
}
}
$dbrec->itemnumber = backup_todb($info['GRADE_ITEM_HISTORY']['#']['ITEMNUMBER']['0']['#']);
$dbrec->iteminfo = backup_todb($info['GRADE_ITEM_HISTORY']['#']['ITEMINFO']['0']['#']);
$dbrec->idnumber = backup_todb($info['GRADE_ITEM_HISTORY']['#']['IDNUMBER']['0']['#']);
$dbrec->calculation = backup_todb($info['GRADE_ITEM_HISTORY']['#']['CALCULATION']['0']['#']);
$dbrec->gradetype = backup_todb($info['GRADE_ITEM_HISTORY']['#']['GRADETYPE']['0']['#']);
$dbrec->grademax = backup_todb($info['GRADE_ITEM_HISTORY']['#']['GRADEMAX']['0']['#']);
$dbrec->grademin = backup_todb($info['GRADE_ITEM_HISTORY']['#']['GRADEMIN']['0']['#']);
if ($oldobj = backup_getid($restore->backup_unique_code, "scale", backup_todb($info['GRADE_ITEM_HISTORY']['#']['SCALEID']['0']['#']))) {
// scaleid is optional
$dbrec->scaleid = $oldobj->new_id;
}
if ($oldobj = backup_getid($restore->backup_unique_code, "grade_outcomes", backup_todb($info['GRADE_ITEM_HISTORY']['#']['OUTCOMEID']['0']['#']))) {
// outcome is optional
$dbrec->outcomeid = $oldobj->new_id;
}
$dbrec->gradepass = backup_todb($info['GRADE_ITEM_HISTORY']['#']['GRADEPASS']['0']['#']);
$dbrec->multfactor = backup_todb($info['GRADE_ITEM_HISTORY']['#']['MULTFACTOR']['0']['#']);
$dbrec->plusfactor = backup_todb($info['GRADE_ITEM_HISTORY']['#']['PLUSFACTOR']['0']['#']);
$dbrec->aggregationcoef = backup_todb($info['GRADE_ITEM_HISTORY']['#']['AGGREGATIONCOEF']['0']['#']);
$dbrec->sortorder = backup_todb($info['GRADE_ITEM_HISTORY']['#']['SORTORDER']['0']['#']);
$dbrec->display = backup_todb($info['GRADE_ITEM_HISTORY']['#']['DISPLAY']['0']['#']);
$dbrec->decimals = backup_todb($info['GRADE_ITEM_HISTORY']['#']['DECIMALS']['0']['#']);
$dbrec->hidden = backup_todb($info['GRADE_ITEM_HISTORY']['#']['HIDDEN']['0']['#']);
$dbrec->locked = backup_todb($info['GRADE_ITEM_HISTORY']['#']['LOCKED']['0']['#']);
$dbrec->locktime = backup_todb($info['GRADE_ITEM_HISTORY']['#']['LOCKTIME']['0']['#']);
$dbrec->needsupdate = backup_todb($info['GRADE_ITEM_HISTORY']['#']['NEEDSUPDATE']['0']['#']);
insert_record('grade_items_history', $dbrec);
unset($dbrec);
}
//Increment counters
$counter++;
//Do some output
if ($counter % 1 == 0) {
if (!defined('RESTORE_SILENTLY')) {
echo ".";
if ($counter % 20 == 0) {
echo "<br />";
}
}
backup_flush(300);
}
}
}
}
}
// process histories
if ($gohcount && $status) {
if (!defined('RESTORE_SILENTLY')) {
echo '<li>' . get_string('gradeoutcomeshistory', 'grades') . '</li>';
}
$counter = 0;
while ($counter < $gohcount) {
//Fetch recordset_size records in each iteration
$recs = get_records_select("backup_ids", "table_name = 'grade_outcomes_history' AND backup_code = '{$restore->backup_unique_code}'", "old_id", "old_id", $counter, $recordset_size);
if ($recs) {
foreach ($recs as $rec) {
//Get the full record from backup_ids
$data = backup_getid($restore->backup_unique_code, 'grade_outcomes_history', $rec->old_id);
if ($data) {
//Now get completed xmlized object
$info = $data->info;
//traverse_xmlize($info); //Debug
//print_object ($GLOBALS['traverse_array']); //Debug
//$GLOBALS['traverse_array']=""; //Debug
$oldobj = backup_getid($restore->backup_unique_code, "grade_outcomes", backup_todb($info['GRADE_OUTCOME_HISTORY']['#']['OLDID']['0']['#']));
if (empty($oldobj->new_id)) {
// if the old object is not being restored, can't restoring its history
$counter++;
continue;
}
$dbrec->oldid = $oldobj->new_id;
$dbrec->action = backup_todb($info['GRADE_OUTCOME_HISTORY']['#']['ACTION']['0']['#']);
$dbrec->source = backup_todb($info['GRADE_OUTCOME_HISTORY']['#']['SOURCE']['0']['#']);
$dbrec->timemodified = backup_todb($info['GRADE_OUTCOME_HISTORY']['#']['TIMEMODIFIED']['0']['#']);
if ($oldobj = backup_getid($restore->backup_unique_code, "user", backup_todb($info['GRADE_OUTCOME_HISTORY']['#']['LOGGEDUSER']['0']['#']))) {
$dbrec->loggeduser = $oldobj->new_id;
}
$dbrec->courseid = $restore->course_id;
$dbrec->shortname = backup_todb($info['GRADE_OUTCOME_HISTORY']['#']['SHORTNAME']['0']['#']);
$dbrec->fullname = backup_todb($info['GRADE_OUTCOME_HISTORY']['#']['FULLNAME']['0']['#']);
$oldobj = backup_getid($restore->backup_unique_code, "scale", backup_todb($info['GRADE_OUTCOME_HISTORY']['#']['SCALEID']['0']['#']));
$dbrec->scaleid = $oldobj->new_id;
$dbrec->description = backup_todb($info['GRADE_OUTCOME_HISTORY']['#']['DESCRIPTION']['0']['#']);
insert_record('grade_outcomes_history', $dbrec);
unset($dbrec);
}
//Increment counters
$counter++;
//Do some output
if ($counter % 1 == 0) {
if (!defined('RESTORE_SILENTLY')) {
echo ".";
if ($counter % 20 == 0) {
echo "<br />";
}
}
backup_flush(300);
}
}
}
}
}
}
if (!defined('RESTORE_SILENTLY')) {
//End ul
echo '</ul>';
}
return $status;
}
$errors = array();
if ($data = $mform->get_data(false)) {
$calculation = calc_formula::unlocalize($data->calculation);
$grade_item->set_calculation($calculation);
redirect($returnurl);
} elseif (!empty($section) and $section = 'idnumbers' and !empty($idnumbers)) {
// Handle idnumbers separately (non-mform)
//first validate and store the new idnumbers
foreach ($idnumbers as $giid => $value) {
if ($gi = grade_item::fetch(array('id' => $giid))) {
if ($gi->itemtype == 'mod') {
$cm = get_coursemodule_from_instance($gi->itemmodule, $gi->iteminstance, $gi->courseid);
} else {
$cm = null;
}
if (!grade_verify_idnumber($value, $COURSE->id, $gi, $cm)) {
$errors[$giid] = get_string('idnumbertaken');
continue;
}
if (empty($gi->idnumber) and !$gi->add_idnumber(stripslashes($idnumbers[$gi->id]))) {
$errors[$giid] = get_string('error');
continue;
}
} else {
$errors[$giid] = 'Could not fetch the grade_item with id=' . $giid;
}
}
}
$gtree = new grade_tree($course->id, false, false);
$strgrades = get_string('grades');
$strgraderreport = get_string('graderreport', 'grades');
function validation($data, $files)
{
global $COURSE, $DB;
$errors = parent::validation($data, $files);
$mform =& $this->_form;
$errors = array();
if ($mform->elementExists('name')) {
$name = trim($data['name']);
if ($name == '') {
$errors['name'] = get_string('required');
}
}
$grade_item = grade_item::fetch(array('itemtype' => 'mod', 'itemmodule' => $data['modulename'], 'iteminstance' => $data['instance'], 'itemnumber' => 0, 'courseid' => $COURSE->id));
if ($data['coursemodule']) {
$cm = $DB->get_record('course_modules', array('id' => $data['coursemodule']));
} else {
$cm = null;
}
if ($mform->elementExists('cmidnumber')) {
// verify the idnumber
if (!grade_verify_idnumber($data['cmidnumber'], $COURSE->id, $grade_item, $cm)) {
$errors['cmidnumber'] = get_string('idnumbertaken');
}
}
// Completion: Don't let them choose automatic completion without turning
// on some conditions
if (array_key_exists('completion', $data) && $data['completion'] == COMPLETION_TRACKING_AUTOMATIC) {
if (empty($data['completionview']) && empty($data['completionusegrade']) && !$this->completion_rule_enabled($data)) {
$errors['completion'] = get_string('badautocompletion', 'completion');
}
}
// Conditions: Don't let them set dates which make no sense
if (array_key_exists('availablefrom', $data) && $data['availablefrom'] && $data['availableuntil'] && $data['availablefrom'] >= $data['availableuntil']) {
$errors['availablefrom'] = get_string('badavailabledates', 'condition');
}
// Conditions: Verify that the grade conditions are numbers, and make sense.
if (array_key_exists('conditiongradegroup', $data)) {
foreach ($data['conditiongradegroup'] as $i => $gradedata) {
if ($gradedata['conditiongrademin'] !== '' && !is_numeric(unformat_float($gradedata['conditiongrademin']))) {
$errors["conditiongradegroup[{$i}]"] = get_string('gradesmustbenumeric', 'condition');
continue;
}
if ($gradedata['conditiongrademax'] !== '' && !is_numeric(unformat_float($gradedata['conditiongrademax']))) {
$errors["conditiongradegroup[{$i}]"] = get_string('gradesmustbenumeric', 'condition');
continue;
}
if ($gradedata['conditiongrademin'] !== '' && $gradedata['conditiongrademax'] !== '' && unformat_float($gradedata['conditiongrademax']) <= unformat_float($gradedata['conditiongrademin'])) {
$errors["conditiongradegroup[{$i}]"] = get_string('badgradelimits', 'condition');
continue;
}
if ($gradedata['conditiongrademin'] === '' && $gradedata['conditiongrademax'] === '' && $gradedata['conditiongradeitemid']) {
$errors["conditiongradegroup[{$i}]"] = get_string('gradeitembutnolimits', 'condition');
continue;
}
if (($gradedata['conditiongrademin'] !== '' || $gradedata['conditiongrademax'] !== '') && !$gradedata['conditiongradeitemid']) {
$errors["conditiongradegroup[{$i}]"] = get_string('gradelimitsbutnoitem', 'condition');
continue;
}
}
}
// Conditions: Verify that the user profile field has not been declared more than once
if (array_key_exists('conditionfieldgroup', $data)) {
// Array to store the existing fields
$arrcurrentfields = array();
// Error message displayed if any condition is declared more than once. We use lang string because
// this way we don't actually generate the string unless there is an error.
$stralreadydeclaredwarning = new lang_string('fielddeclaredmultipletimes', 'condition');
foreach ($data['conditionfieldgroup'] as $i => $fielddata) {
if ($fielddata['conditionfield'] == 0) {
// Don't need to bother if none is selected
continue;
}
if (in_array($fielddata['conditionfield'], $arrcurrentfields)) {
$errors["conditionfieldgroup[{$i}]"] = $stralreadydeclaredwarning->out();
}
// Add the field to the array
$arrcurrentfields[] = $fielddata['conditionfield'];
}
}
return $errors;
}
function validation($data, $files)
{
global $COURSE;
$errors = parent::validation($data, $files);
if (array_key_exists('idnumber', $data)) {
if ($data['id']) {
$grade_item = new grade_item(array('id' => $data['id'], 'courseid' => $data['courseid']));
if ($grade_item->itemtype == 'mod') {
$cm = get_coursemodule_from_instance($grade_item->itemmodule, $grade_item->iteminstance, $grade_item->courseid);
} else {
$cm = null;
}
} else {
$grade_item = null;
$cm = null;
}
if (!grade_verify_idnumber($data['idnumber'], $COURSE->id, $grade_item, $cm)) {
$errors['idnumber'] = get_string('idnumbertaken');
}
}
if (array_key_exists('gradetype', $data) and $data['gradetype'] == GRADE_TYPE_SCALE) {
if (empty($data['scaleid'])) {
$errors['scaleid'] = get_string('missingscale', 'grades');
}
}
if (array_key_exists('grademin', $data) and array_key_exists('grademax', $data)) {
if ($data['grademax'] == $data['grademin'] or $data['grademax'] < $data['grademin']) {
$errors['grademin'] = get_string('incorrectminmax', 'grades');
$errors['grademax'] = get_string('incorrectminmax', 'grades');
}
}
return $errors;
}
$errors = array();
if ($data = $mform->get_data(false)) {
$calculation = calc_formula::unlocalize($data->calculation);
$grade_item->set_calculation($calculation);
redirect($returnurl);
} elseif (!empty($section) and $section = 'idnumbers' and !empty($idnumbers)) {
// Handle idnumbers separately (non-mform)
//first validate and store the new idnumbers
foreach ($idnumbers as $giid => $value) {
if ($gi = grade_item::fetch(array('id' => $giid))) {
if ($gi->itemtype == 'mod') {
$cm = get_coursemodule_from_instance($gi->itemmodule, $gi->iteminstance, $gi->courseid);
} else {
$cm = null;
}
if (!grade_verify_idnumber($value, $gi, $cm)) {
$errors[$giid] = get_string('idnumbertaken');
continue;
}
if (empty($gi->idnumber) and !$gi->add_idnumber(stripslashes($idnumbers[$gi->id]))) {
$errors[$giid] = get_string('error');
continue;
}
} else {
$errors[$giid] = 'Could not fetch the grade_item with id=' . $giid;
}
}
}
$gtree = new grade_tree($course->id, false, false);
$strgrades = get_string('grades');
$strgraderreport = get_string('graderreport', 'grades');
protected function process_module($data)
{
global $CFG, $DB;
$data = (object) $data;
$oldid = $data->id;
$this->task->set_old_moduleversion($data->version);
// Get the current course module data.
$newitemid = $this->task->get_moduleid();
$params = array('id' => $newitemid);
$cmdata = $DB->get_record('course_modules', $params, '*', MUST_EXIST);
// Group mode and Grouping.
$cmdata->groupmode = $data->groupmode;
$cmdata->groupingid = $this->get_mappingid('grouping', $data->groupingid);
// Idnumber uniqueness.
if (!grade_verify_idnumber($data->idnumber, $this->get_courseid())) {
$data->idnumber = '';
}
$cmdata->idnumber = $data->idnumber;
// Completion.
if (!empty($CFG->enablecompletion)) {
$cmdata->completion = $data->completion;
$cmdata->completiongradeitemnumber = $data->completiongradeitemnumber;
$cmdata->completionview = $data->completionview;
$cmdata->completionexpected = $this->apply_date_offset($data->completionexpected);
}
// Availability.
if (empty($CFG->enableavailability)) {
$data->availability = null;
}
if (empty($data->availability)) {
// If there are legacy availablility data fields (and no new format data),
// convert the old fields.
$data->availability = \core_availability\info::convert_legacy_fields($data, false);
} else {
if (!empty($data->groupmembersonly)) {
// There is current availability data, but it still has groupmembersonly
// as well (2.7 backups), convert just that part.
require_once $CFG->dirroot . '/lib/db/upgradelib.php';
$data->availability = upgrade_group_members_only($data->groupingid, $data->availability);
}
}
$cmdata->availability = $data->availability;
// Backups that did not include showdescription, set it to default 0
// (this is not totally necessary as it has a db default, but just to
// be explicit).
if (!isset($data->showdescription)) {
$data->showdescription = 0;
}
$cmdata->showdescription = $data->showdescription;
// Course_module record ready, update it.
$DB->update_record('course_modules', $cmdata);
// Save mapping.
$this->set_mapping('course_module', $oldid, $newitemid);
// Set the new course_module id in the task.
$this->task->set_moduleid($newitemid);
// We can now create the context safely.
$ctxid = context_module::instance($newitemid)->id;
// Set the new context id in the task.
$this->task->set_contextid($ctxid);
// If there is the legacy showavailability data, store this for later use.
// (This data is not present when restoring 'new' backups.)
if (isset($cmdata->showavailability)) {
// Cache the showavailability flag using the backup_ids data field.
restore_dbops::set_backup_ids_record($this->get_restoreid(), 'module_showavailability', $newitemid, 0, null, (object) array('showavailability' => $cmdata->showavailability));
}
}
function validation($data, $files) {
global $COURSE, $DB;
$errors = parent::validation($data, $files);
$mform =& $this->_form;
$errors = array();
if ($mform->elementExists('name')) {
$name = trim($data['name']);
if ($name == '') {
$errors['name'] = get_string('required');
}
}
$grade_item = grade_item::fetch(array('itemtype'=>'mod', 'itemmodule'=>$data['modulename'],
'iteminstance'=>$data['instance'], 'itemnumber'=>0, 'courseid'=>$COURSE->id));
if ($data['coursemodule']) {
$cm = $DB->get_record('course_modules', array('id'=>$data['coursemodule']));
} else {
$cm = null;
}
if ($mform->elementExists('cmidnumber')) {
// verify the idnumber
if (!grade_verify_idnumber($data['cmidnumber'], $COURSE->id, $grade_item, $cm)) {
$errors['cmidnumber'] = get_string('idnumbertaken');
}
}
// Completion: Don't let them choose automatic completion without turning
// on some conditions. Ignore this check when completion settings are
// locked, as the options are then disabled.
if (array_key_exists('completion', $data) &&
$data['completion'] == COMPLETION_TRACKING_AUTOMATIC &&
!empty($data['completionunlocked'])) {
if (empty($data['completionview']) && empty($data['completionusegrade']) &&
!$this->completion_rule_enabled($data)) {
$errors['completion'] = get_string('badautocompletion', 'completion');
}
}
// Conditions: Don't let them set dates which make no sense
if (array_key_exists('availablefrom', $data) &&
$data['availablefrom'] && $data['availableuntil'] &&
$data['availablefrom'] >= $data['availableuntil']) {
$errors['availablefrom'] = get_string('badavailabledates', 'condition');
}
// Conditions: Verify that the grade conditions are numbers, and make sense.
if (array_key_exists('conditiongradegroup', $data)) {
foreach ($data['conditiongradegroup'] as $i => $gradedata) {
if ($gradedata['conditiongrademin'] !== '' &&
!is_numeric(unformat_float($gradedata['conditiongrademin']))) {
$errors["conditiongradegroup[{$i}]"] = get_string('gradesmustbenumeric', 'condition');
continue;
}
if ($gradedata['conditiongrademax'] !== '' &&
!is_numeric(unformat_float($gradedata['conditiongrademax']))) {
$errors["conditiongradegroup[{$i}]"] = get_string('gradesmustbenumeric', 'condition');
continue;
}
if ($gradedata['conditiongrademin'] !== '' && $gradedata['conditiongrademax'] !== '' &&
unformat_float($gradedata['conditiongrademax']) <= unformat_float($gradedata['conditiongrademin'])) {
$errors["conditiongradegroup[{$i}]"] = get_string('badgradelimits', 'condition');
continue;
}
if ($gradedata['conditiongrademin'] === '' && $gradedata['conditiongrademax'] === '' &&
$gradedata['conditiongradeitemid']) {
$errors["conditiongradegroup[{$i}]"] = get_string('gradeitembutnolimits', 'condition');
continue;
}
if (($gradedata['conditiongrademin'] !== '' || $gradedata['conditiongrademax'] !== '') &&
!$gradedata['conditiongradeitemid']) {
$errors["conditiongradegroup[{$i}]"] = get_string('gradelimitsbutnoitem', 'condition');
continue;
}
}
}
return $errors;
}
function validation($data, $files)
{
global $COURSE, $DB;
$errors = parent::validation($data, $files);
$mform =& $this->_form;
$errors = array();
if ($mform->elementExists('name')) {
$name = trim($data['name']);
if ($name == '') {
$errors['name'] = get_string('required');
}
}
$grade_item = grade_item::fetch(array('itemtype' => 'mod', 'itemmodule' => $data['modulename'], 'iteminstance' => $data['instance'], 'itemnumber' => 0, 'courseid' => $COURSE->id));
if ($data['coursemodule']) {
$cm = $DB->get_record('course_modules', array('id' => $data['coursemodule']));
} else {
$cm = null;
}
if ($mform->elementExists('cmidnumber')) {
// verify the idnumber
if (!grade_verify_idnumber($data['cmidnumber'], $COURSE->id, $grade_item, $cm)) {
$errors['cmidnumber'] = get_string('idnumbertaken');
}
}
// Completion: Don't let them choose automatic completion without turning
// on some conditions
if (array_key_exists('completion', $data) && $data['completion'] == COMPLETION_TRACKING_AUTOMATIC) {
if (empty($data['completionview']) && empty($data['completionusegrade']) && !$this->completion_rule_enabled($data)) {
$errors['completion'] = get_string('badautocompletion', 'completion');
}
}
// Conditions: Don't let them set dates which make no sense
if (array_key_exists('availablefrom', $data) && $data['availablefrom'] && $data['availableuntil'] && $data['availablefrom'] > $data['availableuntil']) {
$errors['availablefrom'] = get_string('badavailabledates', 'condition');
}
return $errors;
}
function validation($data, $files)
{
global $COURSE, $DB, $CFG;
$errors = parent::validation($data, $files);
$mform =& $this->_form;
$errors = array();
if ($mform->elementExists('name')) {
$name = trim($data['name']);
if ($name == '') {
$errors['name'] = get_string('required');
}
}
$grade_item = grade_item::fetch(array('itemtype' => 'mod', 'itemmodule' => $data['modulename'], 'iteminstance' => $data['instance'], 'itemnumber' => 0, 'courseid' => $COURSE->id));
if ($data['coursemodule']) {
$cm = $DB->get_record('course_modules', array('id' => $data['coursemodule']));
} else {
$cm = null;
}
if ($mform->elementExists('cmidnumber')) {
// verify the idnumber
if (!grade_verify_idnumber($data['cmidnumber'], $COURSE->id, $grade_item, $cm)) {
$errors['cmidnumber'] = get_string('idnumbertaken');
}
}
// Completion: Don't let them choose automatic completion without turning
// on some conditions. Ignore this check when completion settings are
// locked, as the options are then disabled.
if (array_key_exists('completion', $data) && $data['completion'] == COMPLETION_TRACKING_AUTOMATIC && !empty($data['completionunlocked'])) {
if (empty($data['completionview']) && empty($data['completionusegrade']) && !$this->completion_rule_enabled($data)) {
$errors['completion'] = get_string('badautocompletion', 'completion');
}
}
// Availability: Check availability field does not have errors.
if (!empty($CFG->enableavailability)) {
\core_availability\frontend::report_validation_errors($data, $errors);
}
return $errors;
}
function validation($data, $files)
{
global $COURSE;
$grade_item = false;
if ($data['id']) {
$grade_item = new grade_item(array('id' => $data['id'], 'courseid' => $data['courseid']));
}
$errors = parent::validation($data, $files);
if (array_key_exists('idnumber', $data)) {
if ($grade_item) {
if ($grade_item->itemtype == 'mod') {
$cm = get_coursemodule_from_instance($grade_item->itemmodule, $grade_item->iteminstance, $grade_item->courseid);
} else {
$cm = null;
}
} else {
$grade_item = null;
$cm = null;
}
if (!grade_verify_idnumber($data['idnumber'], $COURSE->id, $grade_item, $cm)) {
$errors['idnumber'] = get_string('idnumbertaken');
}
}
if (array_key_exists('gradetype', $data) and $data['gradetype'] == GRADE_TYPE_SCALE) {
if (empty($data['scaleid'])) {
$errors['scaleid'] = get_string('missingscale', 'grades');
}
}
if (array_key_exists('grademin', $data) and array_key_exists('grademax', $data)) {
if ($data['grademax'] == $data['grademin'] or $data['grademax'] < $data['grademin']) {
$errors['grademin'] = get_string('incorrectminmax', 'grades');
$errors['grademax'] = get_string('incorrectminmax', 'grades');
}
}
// We do not want the user to be able to change the grade type or scale for this item if grades exist.
if ($grade_item && $grade_item->has_grades()) {
// Check that grade type is set - should never not be set unless form has been modified.
if (!isset($data['gradetype'])) {
$errors['gradetype'] = get_string('modgradecantchangegradetype', 'grades');
} else {
if ($data['gradetype'] !== $grade_item->gradetype) {
// Check if we are changing the grade type.
$errors['gradetype'] = get_string('modgradecantchangegradetype', 'grades');
} else {
if ($data['gradetype'] == GRADE_TYPE_SCALE) {
// Check if we are changing the scale - can't do this when grades exist.
if (isset($data['scaleid']) && $data['scaleid'] !== $grade_item->scaleid) {
$errors['scaleid'] = get_string('modgradecantchangescale', 'grades');
}
}
}
}
}
if ($grade_item) {
if ($grade_item->gradetype == GRADE_TYPE_VALUE) {
if (grade_floats_different($data['grademin'], $grade_item->grademin) || grade_floats_different($data['grademax'], $grade_item->grademax)) {
if ($grade_item->has_grades() && empty($data['rescalegrades'])) {
$errors['rescalegrades'] = get_string('mustchooserescaleyesorno', 'grades');
}
}
}
}
return $errors;
}
function validation($data)
{
$errors = array();
if (array_key_exists('idnumber', $data)) {
if ($data['id']) {
$grade_item = new grade_item(array('id' => $data['id'], 'courseid' => $data['courseid']));
if ($grade_item->itemtype == 'mod') {
$cm = get_coursemodule_from_instance($grade_item->itemmodule, $grade_item->iteminstance, $grade_item->courseid);
} else {
$cm = null;
}
} else {
$grade_item = null;
$cm = null;
}
if (!grade_verify_idnumber($data['idnumber'], $grade_item, $cm)) {
$errors['idnumber'] = get_string('idnumbertaken');
}
}
/*
if (array_key_exists('calculation', $data) and $data['calculation'] != '') {
$grade_item = new grade_item(array('id'=>$data['id'], 'itemtype'=>$data['itemtype'], 'courseid'=>$data['courseid']));
$result = $grade_item->validate_formula($data['calculation']);
if ($result !== true) {
$errors['calculation'] = $result;
}
}
*/
if (array_key_exists('grademin', $data) and array_key_exists('grademax', $data)) {
if ($data['grademax'] == $data['grademin'] or $data['grademax'] < $data['grademin']) {
$errors['grademin'] = get_String('incorrectminmax', 'grades');
$errors['grademax'] = get_String('incorrectminmax', 'grades');
}
}
if (0 == count($errors)) {
return true;
} else {
return $errors;
}
}
protected function process_module($data)
{
global $CFG, $DB;
$data = (object) $data;
$oldid = $data->id;
$this->task->set_old_moduleversion($data->version);
$data->course = $this->task->get_courseid();
$data->module = $DB->get_field('modules', 'id', array('name' => $data->modulename));
// Map section (first try by course_section mapping match. Useful in course and section restores)
$data->section = $this->get_mappingid('course_section', $data->sectionid);
if (!$data->section) {
// mapping failed, try to get section by sectionnumber matching
$params = array('course' => $this->get_courseid(), 'section' => $data->sectionnumber);
$data->section = $DB->get_field('course_sections', 'id', $params);
}
if (!$data->section) {
// sectionnumber failed, try to get first section in course
$params = array('course' => $this->get_courseid());
$data->section = $DB->get_field('course_sections', 'MIN(id)', $params);
}
if (!$data->section) {
// no sections in course, create section 0 and 1 and assign module to 1
$sectionrec = array('course' => $this->get_courseid(), 'section' => 0);
$DB->insert_record('course_sections', $sectionrec);
// section 0
$sectionrec = array('course' => $this->get_courseid(), 'section' => 1);
$data->section = $DB->insert_record('course_sections', $sectionrec);
// section 1
}
$data->groupingid = $this->get_mappingid('grouping', $data->groupingid);
// grouping
if (!grade_verify_idnumber($data->idnumber, $this->get_courseid())) {
// idnumber uniqueness
$data->idnumber = '';
}
if (empty($CFG->enablecompletion)) {
// completion
$data->completion = 0;
$data->completiongradeitemnumber = null;
$data->completionview = 0;
$data->completionexpected = 0;
} else {
$data->completionexpected = $this->apply_date_offset($data->completionexpected);
}
if (empty($CFG->enableavailability)) {
$data->availability = null;
}
// Backups that did not include showdescription, set it to default 0
// (this is not totally necessary as it has a db default, but just to
// be explicit).
if (!isset($data->showdescription)) {
$data->showdescription = 0;
}
$data->instance = 0;
// Set to 0 for now, going to create it soon (next step)
if (empty($data->availability)) {
// If there are legacy availablility data fields (and no new format data),
// convert the old fields.
$data->availability = \core_availability\info::convert_legacy_fields($data, false);
} else {
if (!empty($data->groupmembersonly)) {
// There is current availability data, but it still has groupmembersonly
// as well (2.7 backups), convert just that part.
require_once $CFG->dirroot . '/lib/db/upgradelib.php';
$data->availability = upgrade_group_members_only($data->groupingid, $data->availability);
}
}
// course_module record ready, insert it
$newitemid = $DB->insert_record('course_modules', $data);
// save mapping
$this->set_mapping('course_module', $oldid, $newitemid);
// set the new course_module id in the task
$this->task->set_moduleid($newitemid);
// we can now create the context safely
$ctxid = context_module::instance($newitemid)->id;
// set the new context id in the task
$this->task->set_contextid($ctxid);
// update sequence field in course_section
if ($sequence = $DB->get_field('course_sections', 'sequence', array('id' => $data->section))) {
$sequence .= ',' . $newitemid;
} else {
$sequence = $newitemid;
}
$DB->set_field('course_sections', 'sequence', $sequence, array('id' => $data->section));
// If there is the legacy showavailability data, store this for later use.
// (This data is not present when restoring 'new' backups.)
if (isset($data->showavailability)) {
// Cache the showavailability flag using the backup_ids data field.
restore_dbops::set_backup_ids_record($this->get_restoreid(), 'module_showavailability', $newitemid, 0, null, (object) array('showavailability' => $data->showavailability));
}
}
function validation($data, $files)
{
global $COURSE;
$errors = parent::validation($data, $files);
$mform =& $this->_form;
$errors = array();
if ($mform->elementExists('name')) {
$name = trim($data['name']);
if ($name == '') {
$errors['name'] = get_string('required');
}
}
$grade_item = grade_item::fetch(array('itemtype' => 'mod', 'itemmodule' => $data['modulename'], 'iteminstance' => $data['instance'], 'itemnumber' => 0, 'courseid' => $COURSE->id));
if ($data['coursemodule']) {
$cm = get_record('course_modules', 'id', $data['coursemodule']);
} else {
$cm = null;
}
if ($mform->elementExists('cmidnumber')) {
// verify the idnumber
if (!grade_verify_idnumber($data['cmidnumber'], $COURSE->id, $grade_item, $cm)) {
$errors['cmidnumber'] = get_string('idnumbertaken');
}
}
return $errors;
}
function validation($data, $files)
{
global $COURSE;
$errors = parent::validation($data, $files);
if (array_key_exists('idnumber', $data)) {
if ($data['id']) {
$grade_item = new grade_item(array('id' => $data['id'], 'courseid' => $data['courseid']));
} else {
$grade_item = null;
}
if (!grade_verify_idnumber($data['idnumber'], $COURSE->id, $grade_item, null)) {
$errors['idnumber'] = get_string('idnumbertaken');
}
}
return $errors;
}
function validation($data)
{
$errors = array();
if (array_key_exists('idnumber', $data)) {
if ($data['id']) {
$grade_item = new grade_item(array('id' => $data['id'], 'courseid' => $data['courseid']));
} else {
$grade_item = null;
}
if (!grade_verify_idnumber($data['idnumber'], $grade_item, null)) {
$errors['idnumber'] = get_string('idnumbertaken');
}
}
if (0 == count($errors)) {
return true;
} else {
return $errors;
}
}