function definition_after_data()
{
global $CFG;
$mform =& $this->_form;
// first load proper scales
if ($courseid = $mform->getElementValue('courseid')) {
$options = array();
if ($scales = grade_scale::fetch_all_local($courseid)) {
$options[-1] = '--' . get_string('scalescustom');
foreach ($scales as $scale) {
$options[$scale->id] = $scale->get_name();
}
}
if ($scales = grade_scale::fetch_all_global()) {
$options[-2] = '--' . get_string('scalesstandard');
foreach ($scales as $scale) {
$options[$scale->id] = $scale->get_name();
}
}
$scale_el =& $mform->getElement('scaleid');
$scale_el->load($options);
} else {
$options = array();
if ($scales = grade_scale::fetch_all_global()) {
foreach ($scales as $scale) {
$options[$scale->id] = $scale->get_name();
}
}
$scale_el =& $mform->getElement('scaleid');
$scale_el->load($options);
}
if ($id = $mform->getElementValue('id')) {
$outcome = grade_outcome::fetch(array('id' => $id));
$itemcount = $outcome->get_item_uses_count();
$coursecount = $outcome->get_course_uses_count();
if ($itemcount) {
$mform->hardFreeze('scaleid');
}
if (empty($courseid)) {
$mform->hardFreeze('standard');
} else {
if (empty($outcome->courseid) and !has_capability('moodle/grade:manage', get_context_instance(CONTEXT_SYSTEM))) {
$mform->hardFreeze('standard');
} else {
if ($coursecount and empty($outcome->courseid)) {
$mform->hardFreeze('standard');
}
}
}
} else {
if (empty($courseid) or !has_capability('moodle/grade:manage', get_context_instance(CONTEXT_SYSTEM))) {
$mform->hardFreeze('standard');
}
}
}
/**
* Copies the outcomes (and associates to course if necessary) from
* a source emarking activity to a destination one
*
* @param unknown $emarkingsrc
* @param unknown $emarkingdst
* @return boolean
*/
function emarking_copy_course_outcomes($emarkingsrc, $emarkingdst)
{
global $DB, $CFG;
require_once $CFG->libdir . "/gradelib.php";
require_once $CFG->libdir . "/grade/grade_outcome.php";
if (!($coursesrc = $DB->get_record('course', array('id' => $emarkingsrc->course)))) {
return false;
}
if (!($coursedst = $DB->get_record('course', array('id' => $emarkingdst->course)))) {
return false;
}
$params = array($coursesrc->id, $emarkingsrc->id);
$sql = "SELECT outcomeid, itemnumber\n FROM {grade_items}\n WHERE courseid=? AND outcomeid IS NOT NULL\n AND itemmodule = 'emarking' AND iteminstance = ?\n AND itemtype = 'mod'";
$tocopy = $DB->get_records_sql($sql, $params);
$outcomesready = array();
foreach ($tocopy as $outcomeused) {
$outcomesready[] = $outcomeused->outcomeid;
}
$params = array($coursedst->id, $emarkingdst->id);
$sql = "SELECT outcomeid, itemnumber\n FROM {grade_items}\n WHERE courseid=? AND outcomeid IS NOT NULL\n AND itemmodule = 'emarking' AND iteminstance = ?\n AND itemtype = 'mod'";
$realused = $DB->get_records_sql($sql, $params);
$maxitemnumber = 999;
foreach ($realused as $outcomeused) {
if (array_search($outcomeused->outcomeid, $outcomesready)) {
array_remove_by_value($outcomesready, $outcomeused->outcomeid);
}
if ($outcomeused->itemnumber > $maxitemnumber) {
$maxitemnumber = $outcomeused->itemnumber;
}
}
$outcomesdst = grade_outcome::fetch_all_available($emarkingdst->course);
$outcomesavailable = array();
foreach ($outcomesdst as $outcomedst) {
$outcomesavailable[] = $outcomedst->id;
}
if ($maxitemnumber < 1000) {
$maxitemnumber = 1000;
}
foreach ($outcomesready as $outcometocopy) {
$outcome = grade_outcome::fetch(array('id' => $outcometocopy));
if (!array_search($outcometocopy, $outcomesavailable)) {
$outcome->use_in($emarkingdst->course);
}
$outcomeitem = new grade_item();
$outcomeitem->courseid = $emarkingdst->course;
$outcomeitem->itemtype = 'mod';
$outcomeitem->itemmodule = 'emarking';
$outcomeitem->iteminstance = $emarkingdst->id;
$outcomeitem->itemnumber = $maxitemnumber;
$outcomeitem->itemname = $outcome->fullname;
$outcomeitem->outcomeid = $outcome->id;
$outcomeitem->gradetype = GRADE_TYPE_SCALE;
$outcomeitem->scaleid = $outcome->scaleid;
$outcomeitem->insert();
$maxitemnumber++;
}
return true;
}
} else {
$scale_data['courseid'] = 0;
// 'global' : scale use '0', outcomes use null
}
$scale = new grade_scale($scale_data);
$scale_id = $scale->insert();
}
}
// add outcome
$outcome_data = array('shortname' => $csv_data[$imported_headers['outcome_shortname']], 'fullname' => $csv_data[$imported_headers['outcome_name']], 'scaleid' => $scale_id, 'description' => $csv_data[$imported_headers['outcome_description']], 'usermodified' => $USER->id);
if ($local_scope) {
$outcome_data['courseid'] = $courseid;
} else {
$outcome_data['courseid'] = null;
// 'global' : scale use '0', outcomes use null
}
$outcome = new grade_outcome($outcome_data);
$outcome_id = $outcome->insert();
$outcome_success_strings = new StdClass();
$outcome_success_strings->name = $outcome_data['fullname'];
$outcome_success_strings->id = $outcome_id;
echo $OUTPUT->box(get_string('importoutcomesuccess', 'grades', $outcome_success_strings));
}
} else {
echo $OUTPUT->box(get_string('importoutcomenofile', 'grades', 0));
}
// finish
fclose($handle);
// delete temp file
unlink($imported_file);
echo $OUTPUT->footer();
/**
* Adds all the standard elements to a form to edit the settings for an activity module.
*/
function standard_coursemodule_elements()
{
global $COURSE, $CFG, $DB;
$mform =& $this->_form;
$this->_outcomesused = false;
if ($this->_features->outcomes) {
if ($outcomes = grade_outcome::fetch_all_available($COURSE->id)) {
$this->_outcomesused = true;
$mform->addElement('header', 'modoutcomes', get_string('outcomes', 'grades'));
foreach ($outcomes as $outcome) {
$mform->addElement('advcheckbox', 'outcome_' . $outcome->id, $outcome->get_name());
}
}
}
if ($this->_features->rating) {
require_once $CFG->dirroot . '/rating/lib.php';
$rm = new rating_manager();
$mform->addElement('header', 'modstandardratings', get_string('ratings', 'rating'));
$permission = CAP_ALLOW;
$rolenamestring = null;
if (!empty($this->_cm)) {
$context = context_module::instance($this->_cm->id);
$rolenames = get_role_names_with_caps_in_context($context, array('moodle/rating:rate', 'mod/' . $this->_cm->modname . ':rate'));
$rolenamestring = implode(', ', $rolenames);
} else {
$rolenamestring = get_string('capabilitychecknotavailable', 'rating');
}
$mform->addElement('static', 'rolewarning', get_string('rolewarning', 'rating'), $rolenamestring);
$mform->addHelpButton('rolewarning', 'rolewarning', 'rating');
$mform->addElement('select', 'assessed', get_string('aggregatetype', 'rating'), $rm->get_aggregate_types());
$mform->setDefault('assessed', 0);
$mform->addHelpButton('assessed', 'aggregatetype', 'rating');
$mform->addElement('modgrade', 'scale', get_string('scale'), false);
$mform->disabledIf('scale', 'assessed', 'eq', 0);
$mform->addHelpButton('scale', 'modgrade', 'grades');
$mform->setDefault('scale', $CFG->gradepointdefault);
$mform->addElement('checkbox', 'ratingtime', get_string('ratingtime', 'rating'));
$mform->disabledIf('ratingtime', 'assessed', 'eq', 0);
$mform->addElement('date_time_selector', 'assesstimestart', get_string('from'));
$mform->disabledIf('assesstimestart', 'assessed', 'eq', 0);
$mform->disabledIf('assesstimestart', 'ratingtime');
$mform->addElement('date_time_selector', 'assesstimefinish', get_string('to'));
$mform->disabledIf('assesstimefinish', 'assessed', 'eq', 0);
$mform->disabledIf('assesstimefinish', 'ratingtime');
}
//doing this here means splitting up the grade related settings on the lesson settings page
//$this->standard_grading_coursemodule_elements();
$mform->addElement('header', 'modstandardelshdr', get_string('modstandardels', 'form'));
$mform->addElement('modvisible', 'visible', get_string('visible'));
if (!empty($this->_cm)) {
$context = context_module::instance($this->_cm->id);
if (!has_capability('moodle/course:activityvisibility', $context)) {
$mform->hardFreeze('visible');
}
}
if ($this->_features->idnumber) {
$mform->addElement('text', 'cmidnumber', get_string('idnumbermod'));
$mform->setType('cmidnumber', PARAM_RAW);
$mform->addHelpButton('cmidnumber', 'idnumbermod');
}
if ($this->_features->groups) {
$options = array(NOGROUPS => get_string('groupsnone'), SEPARATEGROUPS => get_string('groupsseparate'), VISIBLEGROUPS => get_string('groupsvisible'));
$mform->addElement('select', 'groupmode', get_string('groupmode', 'group'), $options, NOGROUPS);
$mform->addHelpButton('groupmode', 'groupmode', 'group');
}
if ($this->_features->groupings) {
// Groupings selector - used to select grouping for groups in activity.
$options = array();
if ($groupings = $DB->get_records('groupings', array('courseid' => $COURSE->id))) {
foreach ($groupings as $grouping) {
$options[$grouping->id] = format_string($grouping->name);
}
}
core_collator::asort($options);
$options = array(0 => get_string('none')) + $options;
$mform->addElement('select', 'groupingid', get_string('grouping', 'group'), $options);
$mform->addHelpButton('groupingid', 'grouping', 'group');
}
if (!empty($CFG->enableavailability)) {
// Add special button to end of previous section if groups/groupings
// are enabled.
if ($this->_features->groups || $this->_features->groupings) {
$mform->addElement('static', 'restrictgroupbutton', '', html_writer::tag('button', get_string('restrictbygroup', 'availability'), array('id' => 'restrictbygroup', 'disabled' => 'disabled')));
}
// Availability field. This is just a textarea; the user interface
// interaction is all implemented in JavaScript.
$mform->addElement('header', 'availabilityconditionsheader', get_string('restrictaccess', 'availability'));
// Note: This field cannot be named 'availability' because that
// conflicts with fields in existing modules (such as assign).
// So it uses a long name that will not conflict.
$mform->addElement('textarea', 'availabilityconditionsjson', get_string('accessrestrictions', 'availability'));
// The _cm variable may not be a proper cm_info, so get one from modinfo.
if ($this->_cm) {
$modinfo = get_fast_modinfo($COURSE);
$cm = $modinfo->get_cm($this->_cm->id);
} else {
$cm = null;
}
\core_availability\frontend::include_all_javascript($COURSE, $cm);
}
// Conditional activities: completion tracking section
if (!isset($completion)) {
$completion = new completion_info($COURSE);
}
if ($completion->is_enabled()) {
$mform->addElement('header', 'activitycompletionheader', get_string('activitycompletion', 'completion'));
// Unlock button for if people have completed it (will
// be removed in definition_after_data if they haven't)
$mform->addElement('submit', 'unlockcompletion', get_string('unlockcompletion', 'completion'));
$mform->registerNoSubmitButton('unlockcompletion');
$mform->addElement('hidden', 'completionunlocked', 0);
$mform->setType('completionunlocked', PARAM_INT);
$trackingdefault = COMPLETION_TRACKING_NONE;
// If system and activity default is on, set it.
if ($CFG->completiondefault && $this->_features->defaultcompletion) {
$trackingdefault = COMPLETION_TRACKING_MANUAL;
}
$mform->addElement('select', 'completion', get_string('completion', 'completion'), array(COMPLETION_TRACKING_NONE => get_string('completion_none', 'completion'), COMPLETION_TRACKING_MANUAL => get_string('completion_manual', 'completion')));
$mform->setDefault('completion', $trackingdefault);
$mform->addHelpButton('completion', 'completion', 'completion');
// Automatic completion once you view it
$gotcompletionoptions = false;
if (plugin_supports('mod', $this->_modname, FEATURE_COMPLETION_TRACKS_VIEWS, false)) {
$mform->addElement('checkbox', 'completionview', get_string('completionview', 'completion'), get_string('completionview_desc', 'completion'));
$mform->disabledIf('completionview', 'completion', 'ne', COMPLETION_TRACKING_AUTOMATIC);
$gotcompletionoptions = true;
}
// Automatic completion once it's graded
if (plugin_supports('mod', $this->_modname, FEATURE_GRADE_HAS_GRADE, false)) {
$mform->addElement('checkbox', 'completionusegrade', get_string('completionusegrade', 'completion'), get_string('completionusegrade_desc', 'completion'));
$mform->disabledIf('completionusegrade', 'completion', 'ne', COMPLETION_TRACKING_AUTOMATIC);
$mform->addHelpButton('completionusegrade', 'completionusegrade', 'completion');
$gotcompletionoptions = true;
// If using the rating system, there is no grade unless ratings are enabled.
if ($this->_features->rating) {
$mform->disabledIf('completionusegrade', 'assessed', 'eq', 0);
}
}
// Automatic completion according to module-specific rules
$this->_customcompletionelements = $this->add_completion_rules();
foreach ($this->_customcompletionelements as $element) {
$mform->disabledIf($element, 'completion', 'ne', COMPLETION_TRACKING_AUTOMATIC);
}
$gotcompletionoptions = $gotcompletionoptions || count($this->_customcompletionelements) > 0;
// Automatic option only appears if possible
if ($gotcompletionoptions) {
$mform->getElement('completion')->addOption(get_string('completion_automatic', 'completion'), COMPLETION_TRACKING_AUTOMATIC);
}
// Completion expected at particular date? (For progress tracking)
$mform->addElement('date_selector', 'completionexpected', get_string('completionexpected', 'completion'), array('optional' => true));
$mform->addHelpButton('completionexpected', 'completionexpected', 'completion');
$mform->disabledIf('completionexpected', 'completion', 'eq', COMPLETION_TRACKING_NONE);
}
$this->standard_hidden_coursemodule_elements();
}
/**
* Remove all grade related course data
* Grade history is kept
*
* @param int $courseid The course ID
* @param bool $showfeedback If true success notifications will be displayed
*/
function remove_course_grades($courseid, $showfeedback)
{
global $DB, $OUTPUT;
$fs = get_file_storage();
$strdeleted = get_string('deleted');
$course_category = grade_category::fetch_course_category($courseid);
$course_category->delete('coursedelete');
$fs->delete_area_files(get_context_instance(CONTEXT_COURSE, $courseid)->id, 'grade', 'feedback');
if ($showfeedback) {
echo $OUTPUT->notification($strdeleted . ' - ' . get_string('grades', 'grades') . ', ' . get_string('items', 'grades') . ', ' . get_string('categories', 'grades'), 'notifysuccess');
}
if ($outcomes = grade_outcome::fetch_all(array('courseid' => $courseid))) {
foreach ($outcomes as $outcome) {
$outcome->delete('coursedelete');
}
}
$DB->delete_records('grade_outcomes_courses', array('courseid' => $courseid));
if ($showfeedback) {
echo $OUTPUT->notification($strdeleted . ' - ' . get_string('outcomes', 'grades'), 'notifysuccess');
}
if ($scales = grade_scale::fetch_all(array('courseid' => $courseid))) {
foreach ($scales as $scale) {
$scale->delete('coursedelete');
}
}
if ($showfeedback) {
echo $OUTPUT->notification($strdeleted . ' - ' . get_string('scales'), 'notifysuccess');
}
$DB->delete_records('grade_settings', array('courseid' => $courseid));
if ($showfeedback) {
echo $OUTPUT->notification($strdeleted . ' - ' . get_string('settings', 'grades'), 'notifysuccess');
}
}
/**
* Static function returning all local course outcomes
* @static
* @param int $courseid
* @return object
*/
function fetch_all_local($courseid)
{
if (!($outcomes = grade_outcome::fetch_all(array('courseid' => $courseid)))) {
$outcomes = array();
}
return $outcomes;
}
/**
* Instantiates a grade_outcome object whose data is retrieved from the DB,
* if this item's outcomeid variable is set.
* @return object grade_outcome
*/
function load_outcome()
{
if (!empty($this->outcomeid)) {
$this->outcome = grade_outcome::fetch(array('id' => $this->outcomeid));
}
return $this->outcome;
}
/**
* Adds all the standard elements to a form to edit the settings for an activity module.
*/
function standard_coursemodule_elements()
{
global $COURSE, $CFG, $DB;
$mform =& $this->_form;
$this->_outcomesused = false;
if ($this->_features->outcomes) {
if ($outcomes = grade_outcome::fetch_all_available($COURSE->id)) {
$this->_outcomesused = true;
$mform->addElement('header', 'modoutcomes', get_string('outcomes', 'grades'));
foreach ($outcomes as $outcome) {
$mform->addElement('advcheckbox', 'outcome_' . $outcome->id, $outcome->get_name());
}
}
}
if ($this->_features->rating) {
require_once $CFG->dirroot . '/rating/lib.php';
$rm = new rating_manager();
$mform->addElement('header', 'modstandardratings', get_string('ratings', 'rating'));
$permission = CAP_ALLOW;
$rolenamestring = null;
if (!empty($this->_cm)) {
$context = context_module::instance($this->_cm->id);
$rolenames = get_role_names_with_caps_in_context($context, array('moodle/rating:rate', 'mod/' . $this->_cm->modname . ':rate'));
$rolenamestring = implode(', ', $rolenames);
} else {
$rolenamestring = get_string('capabilitychecknotavailable', 'rating');
}
$mform->addElement('static', 'rolewarning', get_string('rolewarning', 'rating'), $rolenamestring);
$mform->addHelpButton('rolewarning', 'rolewarning', 'rating');
$mform->addElement('select', 'assessed', get_string('aggregatetype', 'rating'), $rm->get_aggregate_types());
$mform->setDefault('assessed', 0);
$mform->addHelpButton('assessed', 'aggregatetype', 'rating');
$mform->addElement('modgrade', 'scale', get_string('scale'), false);
$mform->disabledIf('scale', 'assessed', 'eq', 0);
$mform->addElement('checkbox', 'ratingtime', get_string('ratingtime', 'rating'));
$mform->disabledIf('ratingtime', 'assessed', 'eq', 0);
$mform->addElement('date_time_selector', 'assesstimestart', get_string('from'));
$mform->disabledIf('assesstimestart', 'assessed', 'eq', 0);
$mform->disabledIf('assesstimestart', 'ratingtime');
$mform->addElement('date_time_selector', 'assesstimefinish', get_string('to'));
$mform->disabledIf('assesstimefinish', 'assessed', 'eq', 0);
$mform->disabledIf('assesstimefinish', 'ratingtime');
}
//doing this here means splitting up the grade related settings on the lesson settings page
//$this->standard_grading_coursemodule_elements();
$mform->addElement('header', 'modstandardelshdr', get_string('modstandardels', 'form'));
if ($this->_features->groups) {
$options = array(NOGROUPS => get_string('groupsnone'), SEPARATEGROUPS => get_string('groupsseparate'), VISIBLEGROUPS => get_string('groupsvisible'));
$mform->addElement('select', 'groupmode', get_string('groupmode', 'group'), $options, NOGROUPS);
$mform->addHelpButton('groupmode', 'groupmode', 'group');
}
if ($this->_features->groupings or $this->_features->groupmembersonly) {
//groupings selector - used for normal grouping mode or also when restricting access with groupmembersonly
$options = array();
$options[0] = get_string('none');
if ($groupings = $DB->get_records('groupings', array('courseid' => $COURSE->id))) {
foreach ($groupings as $grouping) {
$options[$grouping->id] = format_string($grouping->name);
}
}
$mform->addElement('select', 'groupingid', get_string('grouping', 'group'), $options);
$mform->addHelpButton('groupingid', 'grouping', 'group');
$mform->setAdvanced('groupingid');
}
if ($this->_features->groupmembersonly) {
$mform->addElement('checkbox', 'groupmembersonly', get_string('groupmembersonly', 'group'));
$mform->addHelpButton('groupmembersonly', 'groupmembersonly', 'group');
$mform->setAdvanced('groupmembersonly');
}
$mform->addElement('modvisible', 'visible', get_string('visible'));
if (!empty($this->_cm)) {
$context = context_module::instance($this->_cm->id);
if (!has_capability('moodle/course:activityvisibility', $context)) {
$mform->hardFreeze('visible');
}
}
if ($this->_features->idnumber) {
$mform->addElement('text', 'cmidnumber', get_string('idnumbermod'));
$mform->addHelpButton('cmidnumber', 'idnumbermod');
}
if (!empty($CFG->enableavailability)) {
// String used by conditions
$strnone = get_string('none', 'condition');
// Conditional availability
// Available from/to defaults to midnight because then the display
// will be nicer where it tells users when they can access it (it
// shows only the date and not time).
$date = usergetdate(time());
$midnight = make_timestamp($date['year'], $date['mon'], $date['mday']);
// From/until controls
$mform->addElement('header', 'availabilityconditionsheader', get_string('availabilityconditions', 'condition'));
$mform->addElement('date_time_selector', 'availablefrom', get_string('availablefrom', 'condition'), array('optional' => true, 'defaulttime' => $midnight));
$mform->addHelpButton('availablefrom', 'availablefrom', 'condition');
$mform->addElement('date_time_selector', 'availableuntil', get_string('availableuntil', 'condition'), array('optional' => true, 'defaulttime' => $midnight));
// Conditions based on grades
$gradeoptions = array();
$items = grade_item::fetch_all(array('courseid' => $COURSE->id));
$items = $items ? $items : array();
foreach ($items as $id => $item) {
// Do not include grades for current item
if (!empty($this->_cm) && $this->_cm->instance == $item->iteminstance && $this->_cm->modname == $item->itemmodule && $item->itemtype == 'mod') {
continue;
}
$gradeoptions[$id] = $item->get_name();
}
asort($gradeoptions);
$gradeoptions = array(0 => $strnone) + $gradeoptions;
$grouparray = array();
$grouparray[] =& $mform->createElement('select', 'conditiongradeitemid', '', $gradeoptions);
$grouparray[] =& $mform->createElement('static', '', '', ' ' . get_string('grade_atleast', 'condition') . ' ');
$grouparray[] =& $mform->createElement('text', 'conditiongrademin', '', array('size' => 3));
$grouparray[] =& $mform->createElement('static', '', '', '% ' . get_string('grade_upto', 'condition') . ' ');
$grouparray[] =& $mform->createElement('text', 'conditiongrademax', '', array('size' => 3));
$grouparray[] =& $mform->createElement('static', '', '', '%');
$group = $mform->createElement('group', 'conditiongradegroup', get_string('gradecondition', 'condition'), $grouparray);
// Get version with condition info and store it so we don't ask
// twice
if (!empty($this->_cm)) {
$ci = new condition_info($this->_cm, CONDITION_MISSING_EXTRATABLE);
$this->_cm = $ci->get_full_course_module();
$count = count($this->_cm->conditionsgrade) + 1;
$fieldcount = count($this->_cm->conditionsfield) + 1;
} else {
$count = 1;
$fieldcount = 1;
}
$this->repeat_elements(array($group), $count, array(), 'conditiongraderepeats', 'conditiongradeadds', 2, get_string('addgrades', 'condition'), true);
$mform->addHelpButton('conditiongradegroup[0]', 'gradecondition', 'condition');
// Conditions based on user fields
$operators = condition_info::get_condition_user_field_operators();
$useroptions = condition_info::get_condition_user_fields();
asort($useroptions);
$useroptions = array(0 => $strnone) + $useroptions;
$grouparray = array();
$grouparray[] =& $mform->createElement('select', 'conditionfield', '', $useroptions);
$grouparray[] =& $mform->createElement('select', 'conditionfieldoperator', '', $operators);
$grouparray[] =& $mform->createElement('text', 'conditionfieldvalue');
$mform->setType('conditionfieldvalue', PARAM_RAW);
$group = $mform->createElement('group', 'conditionfieldgroup', get_string('userfield', 'condition'), $grouparray);
$this->repeat_elements(array($group), $fieldcount, array(), 'conditionfieldrepeats', 'conditionfieldadds', 2, get_string('adduserfields', 'condition'), true);
$mform->addHelpButton('conditionfieldgroup[0]', 'userfield', 'condition');
// Conditions based on completion
$completion = new completion_info($COURSE);
if ($completion->is_enabled()) {
$completionoptions = array();
$modinfo = get_fast_modinfo($COURSE);
foreach ($modinfo->cms as $id => $cm) {
// Add each course-module if it:
// (a) has completion turned on
// (b) is not the same as current course-module
if ($cm->completion && (empty($this->_cm) || $this->_cm->id != $id)) {
$completionoptions[$id] = $cm->name;
}
}
asort($completionoptions);
$completionoptions = array(0 => $strnone) + $completionoptions;
$completionvalues = array(COMPLETION_COMPLETE => get_string('completion_complete', 'condition'), COMPLETION_INCOMPLETE => get_string('completion_incomplete', 'condition'), COMPLETION_COMPLETE_PASS => get_string('completion_pass', 'condition'), COMPLETION_COMPLETE_FAIL => get_string('completion_fail', 'condition'));
$grouparray = array();
$grouparray[] =& $mform->createElement('select', 'conditionsourcecmid', '', $completionoptions);
$grouparray[] =& $mform->createElement('select', 'conditionrequiredcompletion', '', $completionvalues);
$group = $mform->createElement('group', 'conditioncompletiongroup', get_string('completioncondition', 'condition'), $grouparray);
$count = empty($this->_cm) ? 1 : count($this->_cm->conditionscompletion) + 1;
$this->repeat_elements(array($group), $count, array(), 'conditioncompletionrepeats', 'conditioncompletionadds', 2, get_string('addcompletions', 'condition'), true);
$mform->addHelpButton('conditioncompletiongroup[0]', 'completioncondition', 'condition');
}
// Do we display availability info to students?
$mform->addElement('select', 'showavailability', get_string('showavailability', 'condition'), array(CONDITION_STUDENTVIEW_SHOW => get_string('showavailability_show', 'condition'), CONDITION_STUDENTVIEW_HIDE => get_string('showavailability_hide', 'condition')));
$mform->setDefault('showavailability', CONDITION_STUDENTVIEW_SHOW);
}
// Conditional activities: completion tracking section
if (!isset($completion)) {
$completion = new completion_info($COURSE);
}
if ($completion->is_enabled()) {
$mform->addElement('header', 'activitycompletionheader', get_string('activitycompletion', 'completion'));
// Unlock button for if people have completed it (will
// be removed in definition_after_data if they haven't)
$mform->addElement('submit', 'unlockcompletion', get_string('unlockcompletion', 'completion'));
$mform->registerNoSubmitButton('unlockcompletion');
$mform->addElement('hidden', 'completionunlocked', 0);
$mform->setType('completionunlocked', PARAM_INT);
$mform->addElement('select', 'completion', get_string('completion', 'completion'), array(COMPLETION_TRACKING_NONE => get_string('completion_none', 'completion'), COMPLETION_TRACKING_MANUAL => get_string('completion_manual', 'completion')));
$mform->setDefault('completion', $this->_features->defaultcompletion ? COMPLETION_TRACKING_MANUAL : COMPLETION_TRACKING_NONE);
$mform->addHelpButton('completion', 'completion', 'completion');
// Automatic completion once you view it
$gotcompletionoptions = false;
if (plugin_supports('mod', $this->_modname, FEATURE_COMPLETION_TRACKS_VIEWS, false)) {
$mform->addElement('checkbox', 'completionview', get_string('completionview', 'completion'), get_string('completionview_desc', 'completion'));
$mform->disabledIf('completionview', 'completion', 'ne', COMPLETION_TRACKING_AUTOMATIC);
$gotcompletionoptions = true;
}
// Automatic completion once it's graded
if (plugin_supports('mod', $this->_modname, FEATURE_GRADE_HAS_GRADE, false)) {
$mform->addElement('checkbox', 'completionusegrade', get_string('completionusegrade', 'completion'), get_string('completionusegrade_desc', 'completion'));
$mform->disabledIf('completionusegrade', 'completion', 'ne', COMPLETION_TRACKING_AUTOMATIC);
$mform->addHelpButton('completionusegrade', 'completionusegrade', 'completion');
$gotcompletionoptions = true;
}
// Automatic completion according to module-specific rules
$this->_customcompletionelements = $this->add_completion_rules();
foreach ($this->_customcompletionelements as $element) {
$mform->disabledIf($element, 'completion', 'ne', COMPLETION_TRACKING_AUTOMATIC);
}
$gotcompletionoptions = $gotcompletionoptions || count($this->_customcompletionelements) > 0;
// Automatic option only appears if possible
if ($gotcompletionoptions) {
$mform->getElement('completion')->addOption(get_string('completion_automatic', 'completion'), COMPLETION_TRACKING_AUTOMATIC);
}
// Completion expected at particular date? (For progress tracking)
$mform->addElement('date_selector', 'completionexpected', get_string('completionexpected', 'completion'), array('optional' => true));
$mform->addHelpButton('completionexpected', 'completionexpected', 'completion');
$mform->disabledIf('completionexpected', 'completion', 'eq', COMPLETION_TRACKING_NONE);
}
$this->standard_hidden_coursemodule_elements();
}
require_login();
require_capability('moodle/grade:manage', $systemcontext);
}
}
// default return url
$gpr = new grade_plugin_return();
$returnurl = $gpr->get_return_url('index.php?id=' . $courseid);
$mform = new edit_outcome_form(null, array('gpr' => $gpr));
$mform->set_data($outcome_rec);
if ($mform->is_cancelled()) {
redirect($returnurl);
} else {
if ($data = $mform->get_data(false)) {
$outcome = new grade_outcome(array('id' => $id));
$data->usermodified = $USER->id;
grade_outcome::set_properties($outcome, $data);
if (empty($outcome->id)) {
if (!has_capability('moodle/grade:manage', $systemcontext)) {
$data->standard = 0;
}
$outcome->courseid = !empty($data->standard) ? null : $courseid;
if (empty($outcome->courseid)) {
$outcome->courseid = null;
}
$outcome->insert();
} else {
if (isset($data->standard)) {
$outcome->courseid = !empty($data->standard) ? null : $courseid;
} else {
unset($outcome->couseid);
// keep previous
/**
* Test get_course_module
*/
public function test_get_course_module()
{
global $DB;
$this->resetAfterTest(true);
$this->setAdminUser();
$course = self::getDataGenerator()->create_course();
$record = array('course' => $course->id, 'name' => 'First Assignment');
$options = array('idnumber' => 'ABC', 'visible' => 0);
// Hidden activity.
$assign = self::getDataGenerator()->create_module('assign', $record, $options);
$outcomescale = 'Distinction, Very Good, Good, Pass, Fail';
// Insert a custom grade scale to be used by an outcome.
$gradescale = new grade_scale();
$gradescale->name = 'gettcoursemodulescale';
$gradescale->courseid = $course->id;
$gradescale->userid = 0;
$gradescale->scale = $outcomescale;
$gradescale->description = 'This scale is used to mark standard assignments.';
$gradescale->insert();
// Insert an outcome.
$data = new stdClass();
$data->courseid = $course->id;
$data->fullname = 'Team work';
$data->shortname = 'Team work';
$data->scaleid = $gradescale->id;
$outcome = new grade_outcome($data, false);
$outcome->insert();
$outcomegradeitem = new grade_item();
$outcomegradeitem->itemname = $outcome->shortname;
$outcomegradeitem->itemtype = 'mod';
$outcomegradeitem->itemmodule = 'assign';
$outcomegradeitem->iteminstance = $assign->id;
$outcomegradeitem->outcomeid = $outcome->id;
$outcomegradeitem->cmid = 0;
$outcomegradeitem->courseid = $course->id;
$outcomegradeitem->aggregationcoef = 0;
$outcomegradeitem->itemnumber = 1;
// The activity's original grade item will be 0.
$outcomegradeitem->gradetype = GRADE_TYPE_SCALE;
$outcomegradeitem->scaleid = $outcome->scaleid;
$outcomegradeitem->insert();
$assignmentgradeitem = grade_item::fetch(array('itemtype' => 'mod', 'itemmodule' => 'assign', 'iteminstance' => $assign->id, 'itemnumber' => 0, 'courseid' => $course->id));
$outcomegradeitem->set_parent($assignmentgradeitem->categoryid);
$outcomegradeitem->move_after_sortorder($assignmentgradeitem->sortorder);
// Test admin user can see the complete hidden activity.
$result = core_course_external::get_course_module($assign->cmid);
$result = external_api::clean_returnvalue(core_course_external::get_course_module_returns(), $result);
$this->assertCount(0, $result['warnings']);
// Test we retrieve all the fields.
$this->assertCount(27, $result['cm']);
$this->assertEquals($record['name'], $result['cm']['name']);
$this->assertEquals($options['idnumber'], $result['cm']['idnumber']);
$this->assertEquals(100, $result['cm']['grade']);
$this->assertEquals(0.0, $result['cm']['gradepass']);
$this->assertEquals('submissions', $result['cm']['advancedgrading'][0]['area']);
$this->assertEmpty($result['cm']['advancedgrading'][0]['method']);
$this->assertEquals($outcomescale, $result['cm']['outcomes'][0]['scale']);
$student = $this->getDataGenerator()->create_user();
$studentrole = $DB->get_record('role', array('shortname' => 'student'));
self::getDataGenerator()->enrol_user($student->id, $course->id, $studentrole->id);
$this->setUser($student);
// The user shouldn't be able to see the activity.
try {
core_course_external::get_course_module($assign->cmid);
$this->fail('Exception expected due to invalid permissions.');
} catch (moodle_exception $e) {
$this->assertEquals('requireloginerror', $e->errorcode);
}
// Make module visible.
set_coursemodule_visible($assign->cmid, 1);
// Test student user.
$result = core_course_external::get_course_module($assign->cmid);
$result = external_api::clean_returnvalue(core_course_external::get_course_module_returns(), $result);
$this->assertCount(0, $result['warnings']);
// Test we retrieve only the few files we can see.
$this->assertCount(11, $result['cm']);
$this->assertEquals($assign->cmid, $result['cm']['id']);
$this->assertEquals($course->id, $result['cm']['course']);
$this->assertEquals('assign', $result['cm']['modname']);
$this->assertEquals($assign->id, $result['cm']['instance']);
}
function RWSUQGrades($r_qiz)
{
$r_gi = grade_item::fetch(array('itemtype' => 'mod', 'itemmodule' => $r_qiz->modulename, 'iteminstance' => $r_qiz->instance, 'itemnumber' => 0, 'courseid' => $r_qiz->course));
if ($r_gi && $r_gi->idnumber != $r_qiz->cmidnumber) {
$r_gi->idnumber = $r_qiz->cmidnumber;
$r_gi->update();
}
$r_its = grade_item::fetch_all(array('itemtype' => 'mod', 'itemmodule' => $r_qiz->modulename, 'iteminstance' => $r_qiz->instance, 'courseid' => $r_qiz->course));
if ($r_its && isset($r_qiz->gradecat)) {
if ($r_qiz->gradecat == -1) {
$r_gcat = new grade_category();
$r_gcat->courseid = $r_qiz->course;
$r_gcat->fullname = $r_qiz->name;
$r_gcat->insert();
if ($r_gi) {
$r_par = $r_gi->get_parent_category();
$r_gcat->set_parent($r_par->id);
}
$r_qiz->gradecat = $r_gcat->id;
}
foreach ($r_its as $r_iti => $r_un) {
$r_its[$r_iti]->set_parent($r_qiz->gradecat);
if ($r_iti == $r_gi->id) {
$r_gi = $r_its[$r_iti];
}
}
}
if ($r_ocs = grade_outcome::fetch_all_available($r_qiz->course)) {
$r_gis = array();
$r_mit = 999;
if ($r_its) {
foreach ($r_its as $r_it) {
if ($r_it->itemnumber > $r_mit) {
$r_mit = $r_it->itemnumber;
}
}
}
foreach ($r_ocs as $r_oc) {
$r_eln = 'outcome_' . $r_oc->id;
if (property_exists($r_qiz, $r_eln) and $r_qiz->{$r_eln}) {
if ($r_its) {
foreach ($r_its as $r_it) {
if ($r_it->outcomeid == $r_oc->id) {
continue 2;
}
}
}
$r_mit++;
$r_oi = new grade_item();
$r_oi->courseid = $r_qiz->course;
$r_oi->itemtype = 'mod';
$r_oi->itemmodule = $r_qiz->modulename;
$r_oi->iteminstance = $r_qiz->instance;
$r_oi->itemnumber = $r_mit;
$r_oi->itemname = $r_oc->fullname;
$r_oi->outcomeid = $r_oc->id;
$r_oi->gradetype = GRADE_TYPE_SCALE;
$r_oi->scaleid = $r_oc->scaleid;
$r_oi->insert();
if ($r_gi) {
$r_oi->set_parent($r_gi->categoryid);
$r_oi->move_after_sortorder($r_gi->sortorder);
} else {
if (isset($r_qiz->gradecat)) {
$r_oi->set_parent($r_qiz->gradecat);
}
}
}
}
}
}
/**
* Adds all the standard elements to a form to edit the settings for an activity module.
*
* @param mixed array or object describing supported features - groups, groupings, groupmembersonly
*/
function standard_coursemodule_elements($features = null)
{
global $COURSE, $CFG;
$mform =& $this->_form;
// deal with legacy $supportgroups param
if ($features === true or $features === false) {
$groupmode = $features;
$features = new object();
$features->groups = $groupmode;
} else {
if (is_array($features)) {
$features = (object) $features;
} else {
if (empty($features)) {
$features = new object();
}
}
}
if (!isset($features->groups)) {
$features->groups = true;
}
if (!isset($features->groupings)) {
$features->groupings = false;
}
if (!isset($features->groupmembersonly)) {
$features->groupmembersonly = false;
}
if (!empty($CFG->enableoutcomes)) {
if ($outcomes = grade_outcome::fetch_all_available($COURSE->id)) {
$mform->addElement('header', 'modoutcomes', get_string('outcomes', 'grades'));
foreach ($outcomes as $outcome) {
$mform->addElement('advcheckbox', 'outcome_' . $outcome->id, $outcome->get_name());
}
}
}
$mform->addElement('header', 'modstandardelshdr', get_string('modstandardels', 'form'));
// if no other elements will be shown, this header should be removed
$showHeader = false;
if ($features->groups) {
$mform->addElement('modgroupmode', 'groupmode', get_string('groupmode'));
$showHeader = true;
}
if (!empty($CFG->enablegroupings)) {
if ($features->groupings or $features->groupmembersonly) {
//groupings selector - used for normal grouping mode or also when restricting access with groupmembersonly
$options = array();
$options[0] = get_string('none');
if ($groupings = get_records('groupings', 'courseid', $COURSE->id)) {
foreach ($groupings as $grouping) {
$options[$grouping->id] = format_string($grouping->name);
}
}
$mform->addElement('select', 'groupingid', get_string('grouping', 'group'), $options);
$mform->setAdvanced('groupingid');
$showHeader = true;
}
if ($features->groupmembersonly) {
$mform->addElement('checkbox', 'groupmembersonly', get_string('groupmembersonly', 'group'));
$mform->setAdvanced('groupmembersonly');
$showHeader = true;
}
}
if (!$showHeader) {
$mform->removeElement('modstandardelshdr');
}
// kowy - this parameter is too dificult to leave setting to a teacher
//$mform->addElement('modvisible', 'visible', get_string('visible'));
//$mform->addElement('text', 'cmidnumber', get_string('idnumber'));
$this->standard_hidden_coursemodule_elements();
}
foreach ($items as $item) {
if (empty($item->outcomeid)) {
continue;
}
if ($item->itemnumber > $max) {
$max = $item->itemnumber;
}
}
$grade_item->itemnumber = $max + 1;
}
} else {
$grade_item->itemnumber = 1000;
}
}
// fix scale used
$outcome = grade_outcome::fetch(array('id' => $data->outcomeid));
$grade_item->gradetype = GRADE_TYPE_SCALE;
$grade_item->scaleid = $outcome->scaleid;
//TODO: we might recalculate existing outcome grades when changing scale
if (empty($grade_item->id)) {
$grade_item->insert();
// move next to activity if adding linked outcome
if ($grade_item->itemtype == 'mod') {
if ($item = grade_item::fetch(array('itemtype' => 'mod', 'itemmodule' => $grade_item->itemmodule, 'iteminstance' => $grade_item->iteminstance, 'itemnumber' => 0, 'courseid' => $COURSE->id))) {
$grade_item->set_parent($item->categoryid);
$grade_item->move_after_sortorder($item->sortorder);
}
}
} else {
$grade_item->update();
}
if ($grade_item) {
$parent = $grade_item->get_parent_category();
$grade_category->set_parent($parent->id);
}
$fromform->gradecat = $grade_category->id;
}
foreach ($items as $itemid => $unused) {
$items[$itemid]->set_parent($fromform->gradecat);
if ($itemid == $grade_item->id) {
// use updated grade_item
$grade_item = $items[$itemid];
}
}
}
// add outcomes if requested
if ($outcomes = grade_outcome::fetch_all_available($course->id)) {
$grade_items = array();
// Outcome grade_item.itemnumber start at 1000, there is nothing above outcomes
$max_itemnumber = 999;
if ($items) {
foreach ($items as $item) {
if ($item->itemnumber > $max_itemnumber) {
$max_itemnumber = $item->itemnumber;
}
}
}
foreach ($outcomes as $outcome) {
$elname = 'outcome_' . $outcome->id;
if (property_exists($fromform, $elname) and $fromform->{$elname}) {
// so we have a request for new outcome grade item?
if ($items) {
/**
* Adds all the standard elements to a form to edit the settings for an activity module.
*/
function standard_coursemodule_elements()
{
global $COURSE, $CFG, $DB;
$mform =& $this->_form;
$outcomesused = false;
if ($this->_features->outcomes) {
if ($outcomes = grade_outcome::fetch_all_available($COURSE->id)) {
$outcomesused = true;
$mform->addElement('header', 'modoutcomes', get_string('outcomes', 'grades'));
foreach ($outcomes as $outcome) {
$mform->addElement('advcheckbox', 'outcome_' . $outcome->id, $outcome->get_name());
}
}
}
$mform->addElement('header', 'modstandardelshdr', get_string('modstandardels', 'form'));
if ($this->_features->groups) {
$options = array(NOGROUPS => get_string('groupsnone'), SEPARATEGROUPS => get_string('groupsseparate'), VISIBLEGROUPS => get_string('groupsvisible'));
$mform->addElement('select', 'groupmode', get_string('groupmode'), $options, NOGROUPS);
$mform->setHelpButton('groupmode', array('groupmode', get_string('groupmode')));
}
if (!empty($CFG->enablegroupings)) {
if ($this->_features->groupings or $this->_features->groupmembersonly) {
//groupings selector - used for normal grouping mode or also when restricting access with groupmembersonly
$options = array();
$options[0] = get_string('none');
if ($groupings = $DB->get_records('groupings', array('courseid' => $COURSE->id))) {
foreach ($groupings as $grouping) {
$options[$grouping->id] = format_string($grouping->name);
}
}
$mform->addElement('select', 'groupingid', get_string('grouping', 'group'), $options);
$mform->setHelpButton('groupingid', array('grouping', get_string('grouping', 'group')));
$mform->setAdvanced('groupingid');
}
if ($this->_features->groupmembersonly) {
$mform->addElement('checkbox', 'groupmembersonly', get_string('groupmembersonly', 'group'));
$mform->setHelpButton('groupmembersonly', array('groupmembersonly', get_string('groupmembersonly', 'group')));
$mform->setAdvanced('groupmembersonly');
}
}
$mform->addElement('modvisible', 'visible', get_string('visible'));
if ($this->_features->idnumber) {
$mform->addElement('text', 'cmidnumber', get_string('idnumbermod'));
$mform->setHelpButton('cmidnumber', array('cmidnumber', get_string('idnumbermod')), true);
}
if ($this->_features->gradecat) {
$categories = grade_get_categories_menu($COURSE->id, $outcomesused);
$mform->addElement('select', 'gradecat', get_string('gradecategory', 'grades'), $categories);
}
if (!empty($CFG->enableavailability)) {
// Conditional availability
$mform->addElement('header', '', get_string('availabilityconditions', 'condition'));
$mform->addElement('date_selector', 'availablefrom', get_string('availablefrom', 'condition'), array('optional' => true));
$mform->setHelpButton('availablefrom', array('conditiondates', get_string('help_conditiondates', 'condition'), 'condition'));
$mform->addElement('date_selector', 'availableuntil', get_string('availableuntil', 'condition'), array('optional' => true));
$mform->setHelpButton('availableuntil', array('conditiondates', get_string('help_conditiondates', 'condition'), 'condition'));
// Conditions based on grades
$gradeoptions = array();
$items = grade_item::fetch_all(array('courseid' => $COURSE->id));
$items = $items ? $items : array();
foreach ($items as $id => $item) {
// Do not include grades for current item
if (!empty($this->_cm) && $this->_cm->instance == $item->iteminstance && $this->_cm->modname == $item->itemmodule && $item->itemtype == 'mod') {
continue;
}
$gradeoptions[$id] = $item->get_name();
}
asort($gradeoptions);
$gradeoptions = array(0 => get_string('none', 'condition')) + $gradeoptions;
$grouparray = array();
$grouparray[] =& $mform->createElement('select', 'conditiongradeitemid', '', $gradeoptions);
$grouparray[] =& $mform->createElement('static', '', '', ' ' . get_string('grade_atleast', 'condition') . ' ');
$grouparray[] =& $mform->createElement('text', 'conditiongrademin', '', array('size' => 3));
$grouparray[] =& $mform->createElement('static', '', '', '% ' . get_string('grade_upto', 'condition') . ' ');
$grouparray[] =& $mform->createElement('text', 'conditiongrademax', '', array('size' => 3));
$grouparray[] =& $mform->createElement('static', '', '', '%');
$mform->setType('conditiongrademin', PARAM_FLOAT);
$mform->setType('conditiongrademax', PARAM_FLOAT);
$group = $mform->createElement('group', 'conditiongradegroup', get_string('gradecondition', 'condition'), $grouparray);
// Get version with condition info and store it so we don't ask
// twice
if (!empty($this->_cm)) {
$ci = new condition_info($this->_cm, CONDITION_MISSING_EXTRATABLE);
$this->_cm = $ci->get_full_course_module();
$count = count($this->_cm->conditionsgrade) + 1;
} else {
$count = 1;
}
$this->repeat_elements(array($group), $count, array(), 'conditiongraderepeats', 'conditiongradeadds', 2, get_string('addgrades', 'condition'), true);
$mform->setHelpButton('conditiongradegroup[0]', array('gradecondition', get_string('help_gradecondition', 'condition'), 'condition'));
// Conditions based on completion
$completion = new completion_info($COURSE);
if ($completion->is_enabled()) {
$completionoptions = array();
$modinfo = get_fast_modinfo($COURSE);
foreach ($modinfo->cms as $id => $cm) {
// Add each course-module if it:
// (a) has completion turned on
// (b) is not the same as current course-module
if ($cm->completion && (empty($this->_cm) || $this->_cm->id != $id)) {
$completionoptions[$id] = $cm->name;
}
}
asort($completionoptions);
$completionoptions = array(0 => get_string('none', 'condition')) + $completionoptions;
$completionvalues = array(COMPLETION_COMPLETE => get_string('completion_complete', 'condition'), COMPLETION_INCOMPLETE => get_string('completion_incomplete', 'condition'), COMPLETION_COMPLETE_PASS => get_string('completion_pass', 'condition'), COMPLETION_COMPLETE_FAIL => get_string('completion_fail', 'condition'));
$grouparray = array();
$grouparray[] =& $mform->createElement('select', 'conditionsourcecmid', '', $completionoptions);
$grouparray[] =& $mform->createElement('select', 'conditionrequiredcompletion', '', $completionvalues);
$group = $mform->createElement('group', 'conditioncompletiongroup', get_string('completioncondition', 'condition'), $grouparray);
$count = empty($this->_cm) ? 1 : count($this->_cm->conditionscompletion) + 1;
$this->repeat_elements(array($group), $count, array(), 'conditioncompletionrepeats', 'conditioncompletionadds', 2, get_string('addcompletions', 'condition'), true);
$mform->setHelpButton('conditioncompletiongroup[0]', array('completioncondition', get_string('help_completioncondition', 'condition'), 'condition'));
}
// Do we display availability info to students?
$mform->addElement('select', 'showavailability', get_string('showavailability', 'condition'), array(CONDITION_STUDENTVIEW_SHOW => get_string('showavailability_show', 'condition'), CONDITION_STUDENTVIEW_HIDE => get_string('showavailability_hide', 'condition')));
$mform->setDefault('showavailability', CONDITION_STUDENTVIEW_SHOW);
$mform->setHelpButton('showavailability', array('showavailability', get_string('help_showavailability', 'condition'), 'condition'));
}
// Conditional activities: completion tracking section
if (!isset($completion)) {
$completion = new completion_info($COURSE);
}
if ($completion->is_enabled()) {
$mform->addElement('header', '', get_string('activitycompletion', 'completion'));
// Unlock button for if people have completed it (will
// be removed in definition_after_data if they haven't)
$mform->addElement('submit', 'unlockcompletion', get_string('unlockcompletion', 'completion'));
$mform->registerNoSubmitButton('unlockcompletion');
$mform->addElement('hidden', 'completionunlocked', 0);
$mform->addElement('select', 'completion', get_string('completion', 'completion'), array(COMPLETION_TRACKING_NONE => get_string('completion_none', 'completion'), COMPLETION_TRACKING_MANUAL => get_string('completion_manual', 'completion')));
$mform->setHelpButton('completion', array('completion', get_string('help_completion', 'completion'), 'completion'));
$mform->setDefault('completion', $this->_features->defaultcompletion ? COMPLETION_TRACKING_MANUAL : COMPLETION_TRACKING_NONE);
// Automatic completion once you view it
$gotcompletionoptions = false;
if (plugin_supports('mod', $this->_modname, FEATURE_COMPLETION_TRACKS_VIEWS, false)) {
$mform->addElement('checkbox', 'completionview', get_string('completionview', 'completion'), get_string('completionview_text', 'completion'));
$mform->setHelpButton('completionview', array('completionview', get_string('help_completionview', 'completion'), 'completion'));
$mform->disabledIf('completionview', 'completion', 'ne', COMPLETION_TRACKING_AUTOMATIC);
$gotcompletionoptions = true;
}
// Automatic completion once it's graded
if (plugin_supports('mod', $this->_modname, FEATURE_GRADE_HAS_GRADE, false)) {
$mform->addElement('checkbox', 'completionusegrade', get_string('completionusegrade', 'completion'), get_string('completionusegrade_text', 'completion'));
$mform->setHelpButton('completionusegrade', array('completionusegrade', get_string('help_completionusegrade', 'completion'), 'completion'));
$mform->disabledIf('completionusegrade', 'completion', 'ne', COMPLETION_TRACKING_AUTOMATIC);
$gotcompletionoptions = true;
}
// Automatic completion according to module-specific rules
$this->_customcompletionelements = $this->add_completion_rules();
foreach ($this->_customcompletionelements as $element) {
$mform->disabledIf($element, 'completion', 'ne', COMPLETION_TRACKING_AUTOMATIC);
}
$gotcompletionoptions = $gotcompletionoptions || count($this->_customcompletionelements) > 0;
// Automatic option only appears if possible
if ($gotcompletionoptions) {
$mform->getElement('completion')->addOption(get_string('completion_automatic', 'completion'), COMPLETION_TRACKING_AUTOMATIC);
}
// Completion expected at particular date? (For progress tracking)
$mform->addElement('date_selector', 'completionexpected', get_string('completionexpected', 'completion'), array('optional' => true));
$mform->setHelpButton('completionexpected', array('completionexpected', get_string('help_completionexpected', 'completion'), 'completion'));
$mform->disabledIf('completionexpected', 'completion', 'eq', COMPLETION_TRACKING_NONE);
}
$this->standard_hidden_coursemodule_elements();
}
if (!confirm_sesskey()) {
break;
}
// $outcome = grade_outcome::fetch(array('id'=>$outcomeid));
$systemcontext = get_context_instance(CONTEXT_SYSTEM);
header("Content-Type: text/csv; charset=utf-8");
// TODO: make the filename more useful, include a date, a specific name, something...
header('Content-Disposition: attachment; filename=outcomes.csv');
// sending header with clear names, to make 'what is what' as easy as possible to understand
$header = array('outcome_name', 'outcome_shortname', 'outcome_description', 'scale_name', 'scale_items', 'scale_description');
echo format_csv($header, ';', '"');
$outcomes = array();
if ($courseid) {
$outcomes = array_merge(grade_outcome::fetch_all_global(), grade_outcome::fetch_all_local($courseid));
} else {
$outcomes = grade_outcome::fetch_all_global();
}
foreach ($outcomes as $outcome) {
$line = array();
$line[] = $outcome->get_name();
$line[] = $outcome->get_shortname();
$line[] = $outcome->description;
$scale = $outcome->load_scale();
$line[] = $scale->get_name();
$line[] = $scale->compact_items();
$line[] = $scale->description;
echo format_csv($line, ';', '"');
}
/**
* Formats and returns a line of data, in CSV format. This code
* is from http://au2.php.net/manual/en/function.fputcsv.php#77866
include_once '../../../config.php';
require_once $CFG->libdir . '/gradelib.php';
require_once $CFG->dirroot . '/grade/lib.php';
$courseid = required_param('id', PARAM_INT);
// course id
if (!($course = get_record('course', 'id', $courseid))) {
print_error('nocourseid');
}
require_login($course->id);
$context = get_context_instance(CONTEXT_COURSE, $course->id);
require_capability('gradereport/outcomes:view', $context);
//first make sure we have proper final grades
grade_regrade_final_grades($courseid);
// Grab all outcomes used in course
$report_info = array();
$outcomes = grade_outcome::fetch_all_available($courseid);
// Get grade_items that use each outcome
foreach ($outcomes as $outcomeid => $outcome) {
$report_info[$outcomeid]['items'] = get_records_select('grade_items', "outcomeid = {$outcomeid} AND courseid = {$courseid}");
$report_info[$outcomeid]['outcome'] = $outcome;
// Get average grades for each item
if (is_array($report_info[$outcomeid]['items'])) {
foreach ($report_info[$outcomeid]['items'] as $itemid => $item) {
$sql = "SELECT itemid, AVG(finalgrade) AS avg, COUNT(finalgrade) AS count\n FROM {$CFG->prefix}grade_grades\n WHERE itemid = {$itemid}\n GROUP BY itemid";
$info = get_records_sql($sql);
if (!$info) {
unset($report_info[$outcomeid]['items'][$itemid]);
continue;
} else {
$info = reset($info);
$avg = round($info->avg, 2);
/**
* Load initial test information
*
* @param string $assignmentname Assignment name
* @param int $student1rawgrade Student 1 grade
* @param int $student2rawgrade Student 2 grade
* @return array Array of vars with test information
*/
protected function load_test_data($assignmentname, $student1rawgrade, $student2rawgrade)
{
global $DB;
// Adds a course, a teacher, 2 students, an assignment and grades for the students.
$course = $this->getDataGenerator()->create_course();
$coursecontext = context_course::instance($course->id);
$studentrole = $DB->get_record('role', array('shortname' => 'student'));
$student1 = $this->getDataGenerator()->create_user();
$this->getDataGenerator()->enrol_user($student1->id, $course->id, $studentrole->id);
$student2 = $this->getDataGenerator()->create_user();
$this->getDataGenerator()->enrol_user($student2->id, $course->id, $studentrole->id);
$teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'));
$teacher = $this->getDataGenerator()->create_user();
$this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
$parent = $this->getDataGenerator()->create_user();
$this->setUser($parent);
$student1context = context_user::instance($student1->id);
// Creates a new role, gives it the capability and gives $USER that role.
$parentroleid = $this->assignUserCapability('moodle/grade:viewall', $student1context->id);
// Enrol the user in the course using the new role.
$this->getDataGenerator()->enrol_user($parent->id, $course->id, $parentroleid);
$assignment = $this->getDataGenerator()->create_module('assign', array('name' => $assignmentname, 'course' => $course->id));
$modcontext = get_coursemodule_from_instance('assign', $assignment->id, $course->id);
$assignment->cmidnumber = $modcontext->id;
$student1grade = array('userid' => $student1->id, 'rawgrade' => $student1rawgrade);
$student2grade = array('userid' => $student2->id, 'rawgrade' => $student2rawgrade);
$studentgrades = array($student1->id => $student1grade, $student2->id => $student2grade);
assign_grade_item_update($assignment, $studentgrades);
// Insert a custom grade scale to be used by an outcome.
$gradescale = new grade_scale();
$gradescale->name = 'unittestscale3';
$gradescale->courseid = $course->id;
$gradescale->userid = 0;
$gradescale->scale = 'Distinction, Very Good, Good, Pass, Fail';
$gradescale->description = 'This scale is used to mark standard assignments.';
$gradescale->insert();
// Insert an outcome.
$data = new stdClass();
$data->courseid = $course->id;
$data->fullname = 'Team work';
$data->shortname = 'Team work';
$data->scaleid = $gradescale->id;
$outcome = new grade_outcome($data, false);
$outcome->insert();
$outcomegradeitem = new grade_item();
$outcomegradeitem->itemname = $outcome->shortname;
$outcomegradeitem->itemtype = 'mod';
$outcomegradeitem->itemmodule = 'assign';
$outcomegradeitem->iteminstance = $assignment->id;
$outcomegradeitem->outcomeid = $outcome->id;
$outcomegradeitem->cmid = 0;
$outcomegradeitem->courseid = $course->id;
$outcomegradeitem->aggregationcoef = 0;
$outcomegradeitem->itemnumber = 1;
// The activity's original grade item will be 0.
$outcomegradeitem->gradetype = GRADE_TYPE_SCALE;
$outcomegradeitem->scaleid = $outcome->scaleid;
// This next two values for testing that returns parameters are correcly formatted.
$outcomegradeitem->set_locked(true);
$outcomegradeitem->hidden = '';
$outcomegradeitem->insert();
$assignmentgradeitem = grade_item::fetch(array('itemtype' => 'mod', 'itemmodule' => 'assign', 'iteminstance' => $assignment->id, 'itemnumber' => 0, 'courseid' => $course->id));
$outcomegradeitem->set_parent($assignmentgradeitem->categoryid);
$outcomegradeitem->move_after_sortorder($assignmentgradeitem->sortorder);
return array($course, $assignment, $student1, $student2, $teacher, $parent);
}
function test_grade_outcome_fetch_all()
{
$grade_outcome = new grade_outcome();
$this->assertTrue(method_exists($grade_outcome, 'fetch_all'));
$grade_outcomes = grade_outcome::fetch_all(array());
$this->assertEqual(count($this->grade_outcomes), count($grade_outcomes));
}
/**
* Create a grade_outcome.
*
* @param array|stdClass $record
* @return stdClass the grade outcome record
*/
public function create_grade_outcome($record = null)
{
global $CFG;
$this->gradeoutcomecounter++;
$i = $this->gradeoutcomecounter;
if (!isset($record['fullname'])) {
$record['fullname'] = 'Grade outcome ' . $i;
}
// For gradelib classes.
require_once $CFG->libdir . '/gradelib.php';
// Create new grading outcome in this course.
$gradeoutcome = new grade_outcome($record, false);
$gradeoutcome->insert();
$gradeoutcome->update_from_db();
return $gradeoutcome->get_record_data();
}
/**
* 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;
}
/**
* Remove all grade related course data - history is kept
*
* @global object
* @param int $courseid
* @param bool $showfeedback print feedback
*/
function remove_course_grades($courseid, $showfeedback) {
global $DB, $OUTPUT;
$strdeleted = get_string('deleted');
$course_category = grade_category::fetch_course_category($courseid);
$course_category->delete('coursedelete');
if ($showfeedback) {
echo $OUTPUT->notification($strdeleted.' - '.get_string('grades', 'grades').', '.get_string('items', 'grades').', '.get_string('categories', 'grades'));
}
if ($outcomes = grade_outcome::fetch_all(array('courseid'=>$courseid))) {
foreach ($outcomes as $outcome) {
$outcome->delete('coursedelete');
}
}
$DB->delete_records('grade_outcomes_courses', array('courseid'=>$courseid));
if ($showfeedback) {
echo $OUTPUT->notification($strdeleted.' - '.get_string('outcomes', 'grades'));
}
if ($scales = grade_scale::fetch_all(array('courseid'=>$courseid))) {
foreach ($scales as $scale) {
$scale->delete('coursedelete');
}
}
if ($showfeedback) {
echo $OUTPUT->notification($strdeleted.' - '.get_string('scales'));
}
$DB->delete_records('grade_settings', array('courseid'=>$courseid));
if ($showfeedback) {
echo $OUTPUT->notification($strdeleted.' - '.get_string('settings', 'grades'));
}
}
/**
* Return information about a course module.
*
* @param int $cmid the course module id
* @return array of warnings and the course module
* @since Moodle 3.0
* @throws moodle_exception
*/
public static function get_course_module($cmid)
{
global $CFG, $DB;
$params = self::validate_parameters(self::get_course_module_parameters(), array('cmid' => $cmid));
$warnings = array();
$cm = get_coursemodule_from_id(null, $params['cmid'], 0, true, MUST_EXIST);
$context = context_module::instance($cm->id);
self::validate_context($context);
// If the user has permissions to manage the activity, return all the information.
if (has_capability('moodle/course:manageactivities', $context)) {
require_once $CFG->dirroot . '/course/modlib.php';
require_once $CFG->libdir . '/gradelib.php';
$info = $cm;
// Get the extra information: grade, advanced grading and outcomes data.
$course = get_course($cm->course);
list($newcm, $newcontext, $module, $extrainfo, $cw) = get_moduleinfo_data($cm, $course);
// Grades.
$gradeinfo = array('grade', 'gradepass', 'gradecat');
foreach ($gradeinfo as $gfield) {
if (isset($extrainfo->{$gfield})) {
$info->{$gfield} = $extrainfo->{$gfield};
}
}
if (isset($extrainfo->grade) and $extrainfo->grade < 0) {
$info->scale = $DB->get_field('scale', 'scale', array('id' => abs($extrainfo->grade)));
}
// Advanced grading.
if (isset($extrainfo->_advancedgradingdata)) {
$info->advancedgrading = array();
foreach ($extrainfo as $key => $val) {
if (strpos($key, 'advancedgradingmethod_') === 0) {
$info->advancedgrading[] = array('area' => str_replace('advancedgradingmethod_', '', $key), 'method' => $val);
}
}
}
// Outcomes.
foreach ($extrainfo as $key => $val) {
if (strpos($key, 'outcome_') === 0) {
if (!isset($info->outcomes)) {
$info->outcomes = array();
}
$id = str_replace('outcome_', '', $key);
$outcome = grade_outcome::fetch(array('id' => $id));
$scaleitems = $outcome->load_scale();
$info->outcomes[] = array('id' => $id, 'name' => external_format_string($outcome->get_name(), $context->id), 'scale' => $scaleitems->scale);
}
}
} else {
// Return information is safe to show to any user.
$info = new stdClass();
$info->id = $cm->id;
$info->course = $cm->course;
$info->module = $cm->module;
$info->modname = $cm->modname;
$info->instance = $cm->instance;
$info->section = $cm->section;
$info->sectionnum = $cm->sectionnum;
$info->groupmode = $cm->groupmode;
$info->groupingid = $cm->groupingid;
$info->completion = $cm->completion;
}
// Format name.
$info->name = external_format_string($cm->name, $context->id);
$result = array();
$result['cm'] = $info;
$result['warnings'] = $warnings;
return $result;
}
$grade_item->move_after_sortorder($item->sortorder);
}
} else {
// set parent if needed
if (isset($data->parentcategory)) {
$grade_item->set_parent($data->parentcategory, 'gradebook');
}
}
} else {
$grade_item->update();
}
// update hiding flag
if ($hiddenuntil) {
$grade_item->set_hidden($hiddenuntil, false);
} else {
$grade_item->set_hidden($hidden, false);
}
$grade_item->set_locktime($locktime);
// locktime first - it might be removed when unlocking
$grade_item->set_locked($locked, false, true);
redirect($returnurl);
}
$PAGE->navbar->add($heading);
print_grade_page_head($courseid, 'settings', null, $heading, false, false, false);
if (!grade_outcome::fetch_all_available($COURSE->id)) {
echo $OUTPUT->confirm(get_string('nooutcomes', 'grades'), $CFG->wwwroot . '/grade/edit/outcome/course.php?id=' . $courseid, $returnurl);
echo $OUTPUT->footer();
die;
}
$mform->display();
echo $OUTPUT->footer();
/**
* Remove all grade related course data - history is kept
* @param int $courseid
* @param bool @showfeedback print feedback
*/
function remove_course_grades($courseid, $showfeedback)
{
$strdeleted = get_string('deleted');
$course_category = grade_category::fetch_course_category($courseid);
$course_category->delete('coursedelete');
if ($showfeedback) {
notify($strdeleted . ' - ' . get_string('grades', 'grades') . ', ' . get_string('items', 'grades') . ', ' . get_string('categories', 'grades'));
}
if ($outcomes = grade_outcome::fetch_all(array('courseid' => $courseid))) {
foreach ($outcomes as $outcome) {
$outcome->delete('coursedelete');
}
}
delete_records('grade_outcomes_courses', 'courseid', $courseid);
if ($showfeedback) {
notify($strdeleted . ' - ' . get_string('outcomes', 'grades'));
}
if ($scales = grade_scale::fetch_all(array('courseid' => $courseid))) {
foreach ($scales as $scale) {
$scale->delete('coursedelete');
}
}
if ($showfeedback) {
notify($strdeleted . ' - ' . get_string('scales'));
}
}
/**
* Common create/update module module actions that need to be processed as soon as a module is created/updaded.
* For example:create grade parent category, add outcomes, rebuild caches, regrade, save plagiarism settings...
* Please note this api does not trigger events as of MOODLE 2.6. Please trigger events before calling this api.
*
* @param object $moduleinfo the module info
* @param object $course the course of the module
*
* @return object moduleinfo update with grading management info
*/
function edit_module_post_actions($moduleinfo, $course)
{
global $CFG;
require_once $CFG->libdir . '/gradelib.php';
$modcontext = context_module::instance($moduleinfo->coursemodule);
$hasgrades = plugin_supports('mod', $moduleinfo->modulename, FEATURE_GRADE_HAS_GRADE, false);
$hasoutcomes = plugin_supports('mod', $moduleinfo->modulename, FEATURE_GRADE_OUTCOMES, true);
// Sync idnumber with grade_item.
if ($hasgrades && ($grade_item = grade_item::fetch(array('itemtype' => 'mod', 'itemmodule' => $moduleinfo->modulename, 'iteminstance' => $moduleinfo->instance, 'itemnumber' => 0, 'courseid' => $course->id)))) {
if ($grade_item->idnumber != $moduleinfo->cmidnumber) {
$grade_item->idnumber = $moduleinfo->cmidnumber;
$grade_item->update();
}
}
if ($hasgrades) {
$items = grade_item::fetch_all(array('itemtype' => 'mod', 'itemmodule' => $moduleinfo->modulename, 'iteminstance' => $moduleinfo->instance, 'courseid' => $course->id));
} else {
$items = array();
}
// Create parent category if requested and move to correct parent category.
if ($items and isset($moduleinfo->gradecat)) {
if ($moduleinfo->gradecat == -1) {
$grade_category = new grade_category();
$grade_category->courseid = $course->id;
$grade_category->fullname = $moduleinfo->name;
$grade_category->insert();
if ($grade_item) {
$parent = $grade_item->get_parent_category();
$grade_category->set_parent($parent->id);
}
$moduleinfo->gradecat = $grade_category->id;
}
$gradecategory = $grade_item->get_parent_category();
foreach ($items as $itemid => $unused) {
$items[$itemid]->set_parent($moduleinfo->gradecat);
if ($itemid == $grade_item->id) {
// Use updated grade_item.
$grade_item = $items[$itemid];
}
if (!empty($moduleinfo->add)) {
if (grade_category::aggregation_uses_aggregationcoef($gradecategory->aggregation)) {
if ($gradecategory->aggregation == GRADE_AGGREGATE_WEIGHTED_MEAN) {
$grade_item->aggregationcoef = 1;
} else {
$grade_item->aggregationcoef = 0;
}
$grade_item->update();
}
}
}
}
require_once $CFG->libdir . '/grade/grade_outcome.php';
// Add outcomes if requested.
if ($hasoutcomes && ($outcomes = grade_outcome::fetch_all_available($course->id))) {
$grade_items = array();
// Outcome grade_item.itemnumber start at 1000, there is nothing above outcomes.
$max_itemnumber = 999;
if ($items) {
foreach ($items as $item) {
if ($item->itemnumber > $max_itemnumber) {
$max_itemnumber = $item->itemnumber;
}
}
}
foreach ($outcomes as $outcome) {
$elname = 'outcome_' . $outcome->id;
if (property_exists($moduleinfo, $elname) and $moduleinfo->{$elname}) {
// So we have a request for new outcome grade item?
if ($items) {
$outcomeexists = false;
foreach ($items as $item) {
if ($item->outcomeid == $outcome->id) {
$outcomeexists = true;
break;
}
}
if ($outcomeexists) {
continue;
}
}
$max_itemnumber++;
$outcome_item = new grade_item();
$outcome_item->courseid = $course->id;
$outcome_item->itemtype = 'mod';
$outcome_item->itemmodule = $moduleinfo->modulename;
$outcome_item->iteminstance = $moduleinfo->instance;
$outcome_item->itemnumber = $max_itemnumber;
$outcome_item->itemname = $outcome->fullname;
$outcome_item->outcomeid = $outcome->id;
$outcome_item->gradetype = GRADE_TYPE_SCALE;
$outcome_item->scaleid = $outcome->scaleid;
$outcome_item->insert();
// Move the new outcome into correct category and fix sortorder if needed.
if ($grade_item) {
$outcome_item->set_parent($grade_item->categoryid);
$outcome_item->move_after_sortorder($grade_item->sortorder);
} else {
if (isset($moduleinfo->gradecat)) {
$outcome_item->set_parent($moduleinfo->gradecat);
}
}
$gradecategory = $outcome_item->get_parent_category();
if ($outcomeexists == false) {
if (grade_category::aggregation_uses_aggregationcoef($gradecategory->aggregation)) {
if ($gradecategory->aggregation == GRADE_AGGREGATE_WEIGHTED_MEAN) {
$outcome_item->aggregationcoef = 1;
} else {
$outcome_item->aggregationcoef = 0;
}
$outcome_item->update();
}
}
}
}
}
if (plugin_supports('mod', $moduleinfo->modulename, FEATURE_ADVANCED_GRADING, false) and has_capability('moodle/grade:managegradingforms', $modcontext)) {
require_once $CFG->dirroot . '/grade/grading/lib.php';
$gradingman = get_grading_manager($modcontext, 'mod_' . $moduleinfo->modulename);
$showgradingmanagement = false;
foreach ($gradingman->get_available_areas() as $areaname => $aretitle) {
$formfield = 'advancedgradingmethod_' . $areaname;
if (isset($moduleinfo->{$formfield})) {
$gradingman->set_area($areaname);
$methodchanged = $gradingman->set_active_method($moduleinfo->{$formfield});
if (empty($moduleinfo->{$formfield})) {
// Going back to the simple direct grading is not a reason to open the management screen.
$methodchanged = false;
}
$showgradingmanagement = $showgradingmanagement || $methodchanged;
}
}
// Update grading management information.
$moduleinfo->gradingman = $gradingman;
$moduleinfo->showgradingmanagement = $showgradingmanagement;
}
rebuild_course_cache($course->id, true);
if ($hasgrades) {
grade_regrade_final_grades($course->id);
}
require_once $CFG->libdir . '/plagiarismlib.php';
plagiarism_save_form_elements($moduleinfo);
return $moduleinfo;
}
function definition()
{
global $COURSE, $CFG;
$mform =& $this->_form;
/// visible elements
$mform->addElement('header', 'general', get_string('gradeoutcomeitem', 'grades'));
$mform->addElement('text', 'itemname', get_string('itemname', 'grades'));
$mform->addRule('itemname', get_string('required'), 'required', null, 'client');
$mform->addElement('text', 'iteminfo', get_string('iteminfo', 'grades'));
$mform->setHelpButton('iteminfo', array('iteminfo', get_string('iteminfo', 'grades'), 'grade'), true);
$mform->addElement('text', 'idnumber', get_string('idnumbermod'));
$mform->setHelpButton('idnumber', array('idnumber', get_string('idnumber', 'grades'), 'grade'), true);
// allow setting of outcomes on module items too
$options = array();
if ($outcomes = grade_outcome::fetch_all_available($COURSE->id)) {
foreach ($outcomes as $outcome) {
$options[$outcome->id] = $outcome->get_name();
}
}
$mform->addElement('selectwithlink', 'outcomeid', get_string('outcome', 'grades'), $options, null, array('link' => $CFG->wwwroot . '/grade/edit/outcome/course.php?id=' . $COURSE->id, 'label' => get_string('outcomeassigntocourse', 'grades')));
$mform->setHelpButton('outcomeid', array('outcomeid', get_string('outcomeid', 'grades'), 'grade'), true);
$mform->addRule('outcomeid', get_string('required'), 'required');
$options = array(0 => get_string('none'));
if ($coursemods = get_course_mods($COURSE->id)) {
foreach ($coursemods as $coursemod) {
if ($mod = get_coursemodule_from_id($coursemod->modname, $coursemod->id)) {
$options[$coursemod->id] = format_string($mod->name);
}
}
}
$mform->addElement('select', 'cmid', get_string('linkedactivity', 'grades'), $options);
$mform->setHelpButton('cmid', array('linkedactivity', get_string('linkedactivity', 'grades'), 'grade'), true);
$mform->setDefault('cmid', 0);
/*$mform->addElement('text', 'gradepass', get_string('gradepass', 'grades'));
$mform->setHelpButton('gradepass', array(false, get_string('gradepass', 'grades'),
false, true, false, get_string('gradepasshelp', 'grades')));*/
/// hiding
/// advcheckbox is not compatible with disabledIf !!
$mform->addElement('checkbox', 'hidden', get_string('hidden', 'grades'));
$mform->setHelpButton('hidden', array('hidden', get_string('hidden', 'grades'), 'grade'));
$mform->addElement('date_time_selector', 'hiddenuntil', get_string('hiddenuntil', 'grades'), array('optional' => true));
$mform->setHelpButton('hiddenuntil', array('hiddenuntil', get_string('hiddenuntil', 'grades'), 'grade'));
$mform->disabledIf('hidden', 'hiddenuntil[off]', 'notchecked');
//locking
$mform->addElement('advcheckbox', 'locked', get_string('locked', 'grades'));
$mform->setHelpButton('locked', array('locked', get_string('locked', 'grades'), 'grade'));
$mform->addElement('date_time_selector', 'locktime', get_string('locktime', 'grades'), array('optional' => true));
$mform->setHelpButton('locktime', array('lockedafter', get_string('locktime', 'grades'), 'grade'));
/// parent category related settings
$mform->addElement('header', 'headerparent', get_string('parentcategory', 'grades'));
$options = array();
$default = '';
$coefstring = '';
$categories = grade_category::fetch_all(array('courseid' => $COURSE->id));
foreach ($categories as $cat) {
$cat->apply_forced_settings();
$options[$cat->id] = $cat->get_name();
if ($cat->is_course_category()) {
$default = $cat->id;
}
if ($cat->is_aggregationcoef_used()) {
if ($cat->aggregation == GRADE_AGGREGATE_WEIGHTED_MEAN) {
$coefstring = ($coefstring == '' or $coefstring == 'aggregationcoefweight') ? 'aggregationcoefweight' : 'aggregationcoef';
} else {
if ($cat->aggregation == GRADE_AGGREGATE_WEIGHTED_MEAN2) {
$coefstring = ($coefstring == '' or $coefstring == 'aggregationcoefextrasum') ? 'aggregationcoefextrasum' : 'aggregationcoef';
} else {
if ($cat->aggregation == GRADE_AGGREGATE_EXTRACREDIT_MEAN) {
$coefstring = ($coefstring == '' or $coefstring == 'aggregationcoefextra') ? 'aggregationcoefextra' : 'aggregationcoef';
} else {
if ($cat->aggregation == GRADE_AGGREGATE_SUM) {
$coefstring = ($coefstring == '' or $coefstring == 'aggregationcoefextrasum') ? 'aggregationcoefextrasum' : 'aggregationcoef';
} else {
$coefstring = 'aggregationcoef';
}
}
}
}
} else {
$mform->disabledIf('aggregationcoef', 'parentcategory', 'eq', $cat->id);
}
}
if (count($categories) > 1) {
$mform->addElement('select', 'parentcategory', get_string('gradecategory', 'grades'), $options);
$mform->disabledIf('parentcategory', 'cmid', 'noteq', 0);
}
if ($coefstring !== '') {
if ($coefstring == 'aggregationcoefextrasum') {
// advcheckbox is not compatible with disabledIf!
$mform->addElement('checkbox', 'aggregationcoef', get_string($coefstring, 'grades'));
} else {
$mform->addElement('text', 'aggregationcoef', get_string($coefstring, 'grades'));
}
$mform->setHelpButton('aggregationcoef', array($coefstring, get_string($coefstring, 'grades'), 'grade'), true);
}
/// hidden params
$mform->addElement('hidden', 'id', 0);
$mform->setType('id', PARAM_INT);
$mform->addElement('hidden', 'courseid', $COURSE->id);
$mform->setType('courseid', PARAM_INT);
/// add return tracking info
$gpr = $this->_customdata['gpr'];
$gpr->add_mform_elements($mform);
/// mark advanced according to site settings
if (isset($CFG->grade_item_advanced)) {
$advanced = explode(',', $CFG->grade_item_advanced);
foreach ($advanced as $el) {
if ($mform->elementExists($el)) {
$mform->setAdvanced($el);
}
}
}
//-------------------------------------------------------------------------------
// buttons
$this->add_action_buttons();
}
/**
* Adds all the standard elements to a form to edit the settings for an activity module.
*
* @param mixed array or object describing supported features - groups, groupings, groupmembersonly, etc.
*/
function standard_coursemodule_elements($features = null)
{
global $COURSE, $CFG;
$mform =& $this->_form;
// deal with legacy $supportgroups param
if ($features === true or $features === false) {
$groupmode = $features;
$this->_features = new object();
$this->_features->groups = $groupmode;
} else {
if (is_array($features)) {
$this->_features = (object) $features;
} else {
if (empty($features)) {
$this->_features = new object();
} else {
$this->_features = $features;
}
}
}
if (!isset($this->_features->groups)) {
$this->_features->groups = true;
}
if (!isset($this->_features->groupings)) {
$this->_features->groupings = false;
}
if (!isset($this->_features->groupmembersonly)) {
$this->_features->groupmembersonly = false;
}
if (!isset($this->_features->outcomes)) {
$this->_features->outcomes = true;
}
if (!isset($this->_features->gradecat)) {
$this->_features->gradecat = true;
}
if (!isset($this->_features->idnumber)) {
$this->_features->idnumber = true;
}
$outcomesused = false;
if (!empty($CFG->enableoutcomes) and $this->_features->outcomes) {
if ($outcomes = grade_outcome::fetch_all_available($COURSE->id)) {
$outcomesused = true;
$mform->addElement('header', 'modoutcomes', get_string('outcomes', 'grades'));
foreach ($outcomes as $outcome) {
$mform->addElement('advcheckbox', 'outcome_' . $outcome->id, $outcome->get_name());
}
}
}
$mform->addElement('header', 'modstandardelshdr', get_string('modstandardels', 'form'));
if ($this->_features->groups) {
$options = array(NOGROUPS => get_string('groupsnone'), SEPARATEGROUPS => get_string('groupsseparate'), VISIBLEGROUPS => get_string('groupsvisible'));
$mform->addElement('select', 'groupmode', get_string('groupmode'), $options, NOGROUPS);
$mform->setHelpButton('groupmode', array('groupmode', get_string('groupmode')));
}
if (!empty($CFG->enablegroupings)) {
if ($this->_features->groupings or $this->_features->groupmembersonly) {
//groupings selector - used for normal grouping mode or also when restricting access with groupmembersonly
$options = array();
$options[0] = get_string('none');
if ($groupings = get_records('groupings', 'courseid', $COURSE->id)) {
foreach ($groupings as $grouping) {
$options[$grouping->id] = format_string($grouping->name);
}
}
$mform->addElement('select', 'groupingid', get_string('grouping', 'group'), $options);
$mform->setHelpButton('groupingid', array('grouping', get_string('grouping', 'group')));
$mform->setAdvanced('groupingid');
}
if ($this->_features->groupmembersonly) {
$mform->addElement('checkbox', 'groupmembersonly', get_string('groupmembersonly', 'group'));
$mform->setHelpButton('groupmembersonly', array('groupmembersonly', get_string('groupmembersonly', 'group')));
$mform->setAdvanced('groupmembersonly');
}
}
$mform->addElement('modvisible', 'visible', get_string('visible'));
if ($this->_features->idnumber) {
$mform->addElement('text', 'cmidnumber', get_string('idnumbermod'));
$mform->setHelpButton('cmidnumber', array('cmidnumber', get_string('idnumbermod')), true);
}
if ($this->_features->gradecat) {
$categories = grade_get_categories_menu($COURSE->id, $outcomesused);
$mform->addElement('select', 'gradecat', get_string('gradecategory', 'grades'), $categories);
}
$this->standard_hidden_coursemodule_elements();
}
require_once '../../../config.php';
require_once $CFG->dirroot . '/grade/lib.php';
require_once $CFG->libdir . '/gradelib.php';
$courseid = required_param('id', PARAM_INT);
/// Make sure they can even access this course
if (!($course = $DB->get_record('course', array('id' => $courseid)))) {
print_error('nocourseid');
}
require_login($course);
$context = get_context_instance(CONTEXT_COURSE, $course->id);
require_capability('moodle/course:update', $context);
/// return tracking object
$gpr = new grade_plugin_return(array('type' => 'edit', 'plugin' => 'outcomes', 'courseid' => $courseid));
// first of all fix the state of outcomes_course table
$standardoutcomes = grade_outcome::fetch_all_global();
$co_custom = grade_outcome::fetch_all_local($courseid);
$co_standard_used = array();
$co_standard_notused = array();
if ($courseused = $DB->get_records('grade_outcomes_courses', array('courseid' => $courseid), '', 'outcomeid')) {
$courseused = array_keys($courseused);
} else {
$courseused = array();
}
// fix wrong entries in outcomes_courses
foreach ($courseused as $oid) {
if (!array_key_exists($oid, $standardoutcomes) and !array_key_exists($oid, $co_custom)) {
$DB->delete_records('grade_outcomes_courses', array('outcomeid' => $oid, 'courseid' => $courseid));
}
}
// fix local custom outcomes missing in outcomes_course
foreach ($co_custom as $oid => $outcome) {
/**
* Validate that the version 1 plugin deletes appropriate associations when
* deleting a course
*/
public function test_version1importdeletecoursedeletesassociations()
{
global $DB, $CFG, $USER;
require_once $CFG->dirroot . '/user/lib.php';
require_once $CFG->dirroot . '/lib/gradelib.php';
require_once $CFG->dirroot . '/group/lib.php';
require_once $CFG->dirroot . '/lib/conditionlib.php';
require_once $CFG->dirroot . '/lib/enrollib.php';
require_once $CFG->dirroot . '/tag/lib.php';
require_once $CFG->dirroot . '/lib/questionlib.php';
// Setup.
$initialnumcontexts = $DB->count_records('context', array('contextlevel' => CONTEXT_COURSE));
$DB->delete_records('block_instances');
// Set up the course with one section, including default blocks.
set_config('defaultblocks_topics', 'search_forums');
set_config('maxsections', 10, 'moodlecourse');
$this->run_core_course_import(array('shortname' => 'deleteassociationsshortname', 'numsections' => 1));
// Create a user record.
$record = new stdClass();
$record->username = '******';
$record->password = '******';
$userid = user_create_user($record);
// Create a course-level role.
$courseid = $DB->get_field('course', 'id', array('shortname' => 'deleteassociationsshortname'));
$coursecontext = context_course::instance($courseid);
$roleid = create_role('deleterole', 'deleterole', 'deleterole');
set_role_contextlevels($roleid, array(CONTEXT_COURSE));
$enrol = new stdClass();
$enrol->enrol = 'manual';
$enrol->courseid = $courseid;
$enrol->status = ENROL_INSTANCE_ENABLED;
if (!$DB->record_exists('enrol', (array) $enrol)) {
$DB->insert_record('enrol', $enrol);
}
// Assign the user to the course-level role.
enrol_try_internal_enrol($courseid, $userid, $roleid);
// Create a grade item.
$gradeitem = new grade_item(array('courseid' => $courseid, 'itemtype' => 'manual', 'itemname' => 'testitem'), false);
$gradeitem->insert();
$gradegrade = new grade_grade(array('itemid' => $gradeitem->id, 'userid' => $userid), false);
// Assign the user a grade.
$gradegrade->insert();
// Create a grade outcome.
$gradeoutcome = new grade_outcome(array('courseid' => $courseid, 'shortname' => 'bogusshortname', 'fullname' => 'bogusfullname'));
$gradeoutcome->insert();
// Create a grade scale.
$gradescale = new grade_scale(array('courseid' => $courseid, 'name' => 'bogusname', 'userid' => $userid, 'scale' => 'bogusscale', 'description' => 'bogusdescription'));
$gradescale->insert();
// Set a grade setting value.
grade_set_setting($courseid, 'bogus', 'bogus');
// Set up a grade letter.
$gradeletter = new stdClass();
$gradeletter->contextid = $coursecontext->id;
$gradeletter->lowerboundary = 80;
$gradeletter->letter = 'A';
$DB->insert_record('grade_letters', $gradeletter);
// Set up a forum instance.
$forum = new stdClass();
$forum->course = $courseid;
$forum->intro = 'intro';
$forum->id = $DB->insert_record('forum', $forum);
// Add it as a course module.
$forum->module = $DB->get_field('modules', 'id', array('name' => 'forum'));
$forum->instance = $forum->id;
$cmid = add_course_module($forum);
// Set up a completion record.
$completion = new stdClass();
$completion->coursemoduleid = $cmid;
$completion->completionstate = 0;
$completion->userid = 9999;
$completion->timemodified = time();
$DB->insert_record('course_modules_completion', $completion);
// Set up a completion condition.
$forum->id = $cmid;
$ci = new condition_info($forum, CONDITION_MISSING_EVERYTHING, false);
$ci->add_completion_condition($cmid, COMPLETION_ENABLED);
// Set the blocks position.
$instances = $DB->get_records('block_instances', array('parentcontextid' => $coursecontext->id));
$page = new stdClass();
$page->context = $coursecontext;
$page->pagetype = 'course-view-*';
$page->subpage = false;
foreach ($instances as $instance) {
blocks_set_visibility($instance, $page, 1);
}
// Create a group.
$group = new stdClass();
$group->name = 'testgroup';
$group->courseid = $courseid;
$groupid = groups_create_group($group);
// Add the user to the group.
groups_add_member($groupid, $userid);
// Create a grouping containing our group.
$grouping = new stdClass();
$grouping->name = 'testgrouping';
$grouping->courseid = $courseid;
$groupingid = groups_create_grouping($grouping);
groups_assign_grouping($groupingid, $groupid);
// Set up a user tag.
tag_set('course', $courseid, array('testtag'));
// Add a course-level log.
add_to_log($courseid, 'bogus', 'bogus');
// Set up the default course question category.
$newcategory = question_make_default_categories(array($coursecontext));
// Create a test question.
$question = new stdClass();
$question->qtype = 'truefalse';
$form = new stdClass();
$form->category = $newcategory->id;
$form->name = 'testquestion';
$form->correctanswer = 1;
$form->feedbacktrue = array('text' => 'bogustext', 'format' => FORMAT_HTML);
$form->feedbackfalse = array('text' => 'bogustext', 'format' => FORMAT_HTML);
$question = question_bank::get_qtype('truefalse')->save_question($question, $form);
if (function_exists('course_set_display')) {
// Set a "course display" setting.
course_set_display($courseid, 1);
}
// Make a bogus backup record.
$backupcourse = new stdClass();
$backupcourse->courseid = $courseid;
$DB->insert_record('backup_courses', $backupcourse);
// Add a user lastaccess record.
$lastaccess = new stdClass();
$lastaccess->userid = $userid;
$lastaccess->courseid = $courseid;
$DB->insert_record('user_lastaccess', $lastaccess);
// Make a bogus backup log record.
$log = new stdClass();
$log->backupid = $courseid;
$log->timecreated = time();
$log->loglevel = 1;
$log->message = 'bogus';
$DB->insert_record('backup_logs', $log);
// Get initial counts.
$initialnumcourse = $DB->count_records('course');
$initialnumroleassignments = $DB->count_records('role_assignments');
$initialnumuserenrolments = $DB->count_records('user_enrolments');
$initialnumgradeitems = $DB->count_records('grade_items');
$initialnumgradegrades = $DB->count_records('grade_grades');
$initialnumgradeoutcomes = $DB->count_records('grade_outcomes');
$initialnumgradeoutcomescourses = $DB->count_records('grade_outcomes_courses');
$initialnumscale = $DB->count_records('scale');
$initialnumgradesettings = $DB->count_records('grade_settings');
$initialnumgradeletters = $DB->count_records('grade_letters');
$initialnumforum = $DB->count_records('forum');
$initialnumcoursemodules = $DB->count_records('course_modules');
$initialnumcoursemodulescompletion = $DB->count_records('course_modules_completion');
$initialnumcoursemodulesavailability = $DB->count_records('course_modules_availability');
$initialnumblockinstances = $DB->count_records('block_instances');
$initialnumblockpositions = $DB->count_records('block_positions');
$initialnumgroups = $DB->count_records('groups');
$initialnumgroupsmembers = $DB->count_records('groups_members');
$initialnumgroupings = $DB->count_records('groupings');
$initialnumgroupingsgroups = $DB->count_records('groupings_groups');
$initialnumtaginstance = $DB->count_records('tag_instance');
$initialnumcoursesections = $DB->count_records('course_sections');
$initialnumquestioncategories = $DB->count_records('question_categories');
$initialnumquestion = $DB->count_records('question');
if (self::$coursedisplay) {
$initialnumcoursedisplay = $DB->count_records('course_display');
}
$initialnumbackupcourses = $DB->count_records('backup_courses');
$initialnumuserlastaccess = $DB->count_records('user_lastaccess');
$initialnumbackuplogs = $DB->count_records('backup_logs');
// Delete the course.
$data = array('action' => 'delete', 'shortname' => 'deleteassociationsshortname');
$this->run_core_course_import($data, false);
// Validate the result.
$this->assertEquals($DB->count_records('course'), $initialnumcourse - 1);
$this->assertEquals($DB->count_records('role_assignments'), $initialnumroleassignments - 1);
$this->assertEquals($DB->count_records('user_enrolments'), $initialnumuserenrolments - 1);
$this->assertEquals($DB->count_records('grade_items'), $initialnumgradeitems - 2);
$this->assertEquals($DB->count_records('grade_grades'), $initialnumgradegrades - 1);
$this->assertEquals($DB->count_records('grade_outcomes'), $initialnumgradeoutcomes - 1);
$this->assertEquals($DB->count_records('grade_outcomes_courses'), $initialnumgradeoutcomescourses - 1);
$this->assertEquals($DB->count_records('scale'), $initialnumscale - 1);
$this->assertEquals($DB->count_records('grade_settings'), $initialnumgradesettings - 1);
$this->assertEquals($DB->count_records('grade_letters'), $initialnumgradeletters - 1);
$this->assertEquals($DB->count_records('forum'), $initialnumforum - 1);
$this->assertEquals($DB->count_records('course_modules'), $initialnumcoursemodules - 1);
/*
Uncomment the two lines below when this fix is available: http://tracker.moodle.org/browse/MDL-32988
$this->assertEquals($DB->count_records('course_modules_completion'), $initialnumcourse_modules_completion - 1);
$this->assertEquals($DB->count_records('course_modules_availability'), $initialnumcourse_modules_availability - 1);
*/
$this->assertEquals($initialnumblockinstances - 4, $DB->count_records('block_instances'));
$this->assertEquals($DB->count_records('block_positions'), 0);
$this->assertEquals($DB->count_records('groups'), $initialnumgroups - 1);
$this->assertEquals($DB->count_records('groups_members'), $initialnumgroupsmembers - 1);
$this->assertEquals($DB->count_records('groupings'), $initialnumgroupings - 1);
$this->assertEquals($DB->count_records('groupings_groups'), $initialnumgroupingsgroups - 1);
$this->assertEquals($DB->count_records('log', array('course' => $courseid)), 0);
$this->assertEquals($DB->count_records('tag_instance'), $initialnumtaginstance - 1);
$this->assertEquals($DB->count_records('course_sections'), $initialnumcoursesections - 1);
$this->assertEquals($DB->count_records('question_categories'), $initialnumquestioncategories - 1);
$this->assertEquals($DB->count_records('question'), $initialnumquestion - 1);
if (self::$coursedisplay) {
$this->assertEquals($DB->count_records('course_display'), $initialnumcoursedisplay - 1);
}
$this->assertEquals($DB->count_records('backup_courses'), $initialnumbackupcourses - 1);
$this->assertEquals($DB->count_records('user_lastaccess'), $initialnumuserlastaccess - 1);
}
