mirror_php/moodle
1
0
Fork 0
mirror of https://github.com/moodle/moodle.git synced 2025-04-24 01:44:27 +02:00
Code Issues Projects Releases Wiki Activity

MDL-9317 Applying Petr's second patch

Browse Source
This commit is contained in:
nicolasconnault 2007-05-29 00:56:44 +00:00
parent e72be0548e
commit de420c11c5
16 changed files with 575 additions and 271 deletions

8
admin/cron.php

@ -261,11 +261,11 @@
}
}
// attemps to grab grades from third party/non-stard mods, or mods with no event
// implemented for 1.9 and above.
mtrace("Grabbing grades from modules if required...");
// attemps to grab grades from third party/non-stard mods that still have xxx_grades() in lib.php
// which was obsoleted in 1.9.
mtrace("Grabbing grades from older modules if required...");
include_once($CFG->dirroot.'/lib/gradelib.php');
grades_grab_grades();
grade_grab_legacy_grades();
} // End of occasional clean-up tasks

2
grade/import/csv/index.php

@ -109,7 +109,7 @@ if (($formdata = data_submitted()) && !empty($formdata->map)) {
$eventdata->idnumber = $idnumber;
$eventdata->userid = $studentid;
$eventdata->gradevalue = $studentgrade;
events_trigger('grade_added', $eventdata);
events_trigger('grade_updated_external', $eventdata);
debugging("triggering event for $idnumber... student id is $studentid and grade is $studentgrade");
}

2
grade/import/xml/index.php

@ -60,7 +60,7 @@ if ( $formdata = $mform->get_data() ) {
$eventdata->userid = $result['#']['student'][0]['#'];
$eventdata->gradevalue = $result['#']['score'][0]['#'];
trigger_event('grade_added', $eventdata);
trigger_event('grade_updated_external', $eventdata);
echo "<br/>triggering event for $eventdata->idnumber... student id is $eventdata->userid and grade is $eventdata->gradevalue";
}
}

39
lib/db/events.php

@ -26,8 +26,43 @@
///////////////////////////////////////////////////////////////////////////
$events = array (
'grade_added' => array ( // All new grades get processed immediately by the gradebook
$handlers = array (
/*
* Grades added by activities
*
* required parameters (object or array):
* itemid - if from grade_items table, grade item must already exist
* userid - each grade must be associated to existing user
*
* optional params:
* gradevalue - raw grade value
* feedback - graders feedback
* feedbackformat - text format of the feedback
*/
'grade_updated' => array (
'handlerfile' => '/lib/gradelib.php',
'handlerfunction' => 'grade_handler',
'schedule' => 'instant'
),
/*
* Grades created/modified outside of activities (import, gradebook overrides, etc.)
*
* required parameters (object or array):
* itemid - id from grade_items table, grade item must already exist
* userid - each grade must be associated with existing user
*
* optional params:
* gradevalue - raw grade value
* feedback - graders feedback
* feedbackformat - text format of the feedback
*
* optional params (improves performance):
* itemtype - mod, block
* itemmodule - assignment, etc.
*/
'grade_updated_external' => array (
'handlerfile' => '/lib/gradelib.php',
'handlerfunction' => 'grade_handler',
'schedule' => 'instant'

4
lib/db/install.xml

@ -1189,10 +1189,10 @@
<INDEX NAME="mnethostid_username" UNIQUE="true" FIELDS="mnet_host_id, username"/>
</INDEXES>
</TABLE>
<TABLE NAME="events_handlers" COMMENT="This table is for storing which components requests what type of event, and the location of the responsible handlers. For example, the grade book can register 'grade_added' event with a function add_grade() that should be called event time an 'grade_added' event is triggered by a module." PREVIOUS="mnet_sso_access_control" NEXT="events_queue">
<TABLE NAME="events_handlers" COMMENT="This table is for storing which components requests what type of event, and the location of the responsible handlers. For example, the grade book can register 'grade_updated' event with a function grade_handler() that should be called event time an 'grade_updated' event is triggered by a module." PREVIOUS="mnet_sso_access_control" NEXT="events_queue">
<FIELDS>
<FIELD NAME="id" TYPE="int" LENGTH="10" NOTNULL="true" UNSIGNED="false" SEQUENCE="true" ENUM="false" COMMENT="id of the table, please edit me" NEXT="eventname"/>
<FIELD NAME="eventname" TYPE="char" LENGTH="166" NOTNULL="true" SEQUENCE="false" ENUM="false" COMMENT="name of the event, e.g. 'grade_added'" PREVIOUS="id" NEXT="handlermodule"/>
<FIELD NAME="eventname" TYPE="char" LENGTH="166" NOTNULL="true" SEQUENCE="false" ENUM="false" COMMENT="name of the event, e.g. 'grade_updated'" PREVIOUS="id" NEXT="handlermodule"/>
<FIELD NAME="handlermodule" TYPE="char" LENGTH="166" NOTNULL="true" SEQUENCE="false" ENUM="false" COMMENT="e.g. moodle, mod/forum, block/rss_client" PREVIOUS="eventname" NEXT="handlerfile"/>
<FIELD NAME="handlerfile" TYPE="char" LENGTH="255" NOTNULL="true" SEQUENCE="false" ENUM="false" COMMENT="path to the file of the function, eg /grade/export/lib.php" PREVIOUS="handlermodule" NEXT="handlerfunction"/>
<FIELD NAME="handlerfunction" TYPE="text" LENGTH="medium" NOTNULL="false" SEQUENCE="false" ENUM="false" COMMENT="serialized string or array describing function, suitable to be passed to call_user_func()" PREVIOUS="handlerfile" NEXT="schedule"/>

4
lib/eventslib.php

@ -53,13 +53,13 @@ function events_load_def($component) {
}
}
$events = array(); // TODO: $handlers might be better here ;-)
$handlers = array();
if (file_exists($defpath)) {
require($defpath);
}
return $events;
return $handlers;
}
/**

4
lib/grade/grade_object.php

@ -107,7 +107,7 @@ class grade_object {
function insert() {
global $USER;
if (!empty($this->id)) { // Object already exists, so let's do an update instead
if (!empty($this->id)) {
debugging("Grade object already exists!");
return false;
}
@ -120,7 +120,7 @@ class grade_object {
$clonethis = fullclone($this);
// Unset non-set fields
// Unset non-set and null fields
foreach ($clonethis as $var => $val) {
if (!isset($val)) {
unset($clonethis->$var);

194
lib/gradelib.php

@ -66,28 +66,26 @@ require_once($CFG->libdir . '/grade/grade_tree.php');
* type will be returned, etc...
*
* @param int $courseid The id of the course to which the grade items belong
* @param string $itemname The name of the grade item
* @param string $itemtype 'mod', 'blocks', 'import', 'calculated' etc
* @param string $itemmodule 'forum, 'quiz', 'csv' etc
* @param int $iteminstance id of the item module
* @param string $itemname The name of the grade item
* @param int $itemnumber Can be used to distinguish multiple grades for an activity
* @param int $idnumber grade item Primary Key
* @return array An array of grade items
*/
function grade_get_items($courseid, $itemname=NULL, $itemtype=NULL, $itemmodule=NULL, $iteminstance=NULL, $itemnumber=NULL, $idnumber=NULL) {
$grade_item = new grade_item(compact('courseid', 'itemname', 'itemtype', 'itemmodule', 'iteminstance', 'itemnumber', 'idnumber'), false);
function grade_get_items($courseid, $itemtype=NULL, $itemmodule=NULL, $iteminstance=NULL, $itemname=NULL, $itemnumber=NULL, $idnumber=NULL) {
$grade_item = new grade_item(compact('courseid', 'itemtype', 'itemmodule', 'iteminstance', 'itemname', 'itemnumber', 'idnumber'), false);
$grade_items = $grade_item->fetch_all_using_this();
return $grade_items;
}
/**
* Creates a new grade_item in case it doesn't exist. This function would be called when a module
* is created or updates, for example, to ensure grade_item entries exist.
* It's not essential though--if grades are being added later and a matching grade_item doesn't
* yet exist, the gradebook will create them on the fly.
*
* @param
* Creates a new grade_item in case it doesn't exist.
* This function is called when a new module is created.
*
* @param mixed $params array or object
* @return mixed New grade_item id if successful
*/
function grade_create_item($params) {
@ -96,6 +94,7 @@ function grade_create_item($params) {
if (empty($grade_item->id)) {
return $grade_item->insert();
} else {
debugging('Grade item already exists - id:'.$grade_item->id);
return $grade_item->id;
}
}
@ -171,14 +170,14 @@ function grade_update_final_grades($courseid=NULL, $gradeitemid=NULL) {
return $count;
}
/*
/**
* For backward compatibility with old third-party modules, this function is called
* via to admin/cron.php to search all mod/xxx/lib.php files for functions named xxx_grades(),
* if the current modules does not have grade events registered with the grade book.
* Once the data is extracted, the events_trigger() function can be called to initiate
* an event as usual and copy/ *upgrade the data in the gradebook tables.
*/
function grades_grab_grades() {
function grade_grab_legacy_grades() {
global $CFG, $db;
@ -197,55 +196,57 @@ function grades_grab_grades() {
// include the module lib once
if (file_exists($fullmod.'/lib.php')) {
include_once($fullmod.'/lib.php');
// look for mod_grades() function - old grade book pulling function
// to see if module supports grades, and check for event registration status
// look for modname_grades() function - old gradebook pulling function
// if present sync the grades with new grading system
$gradefunc = $mod.'_grades';
// if this mod has grades, but grade_added event is not registered
// then we need to pull grades into the new gradebook
if (function_exists($gradefunc) && !events_is_registered($gradefunc, $mod)) {//TODO: the use of $gradefunct as eventname here does not seem to be correct
// get all instance of the mod
$module = get_record('modules', 'name', $mod);
if ($module && $modinstances = get_records_select('course_modules cm, '.$CFG->prefix.$mod.' m', 'cm.module = '.$module->id.' AND m.id = cm.instance')) {
if (function_exists($gradefunc)) {
// get all instance of the activity
$sql = "SELECT a.*, cm.idnumber as cmidnumber, a.course as courseid, m.name as modname FROM {$CFG->prefix}$mod a, {$CFG->prefix}course_modules cm, {$CFG->prefix}modules m
WHERE m.name='$mod' AND m.id=cm.module AND cm.instance=a.id";
if ($modinstances = get_records_sql($sql)) {
foreach ($modinstances as $modinstance) {
// for each instance, call the xxx_grades() function
if ($grades = $gradefunc($modinstance->instance)) {
$maxgrade = $grades->maxgrade;
if (is_numeric($maxgrade)) {
// no scale used
$scaleid = null;
} else {
if ($grades = $gradefunc($modinstance->id)) {
$grademax = $grades->maxgrade;
$scaleid = 0;
if (!is_numeric($grademax)) {
// scale name is provided as a string, try to find it
$scale = get_record('scale', 'name', $maxgrade);
if (!$scale = get_record('scale', 'name', $grademax)) {
debugging('Incorrect scale name! name:'.$grademax);
continue;
}
$scaleid = $scale->id;
$maxgrade = null;
}
if (!$grade_item = grade_get_legacy_grade_item($modinstance, $grademax, $scaleid)) {
debugging('Can not get/create legacy grade item!');
continue;
}
foreach ($grades->grades as $userid=>$usergrade) {
// make the grade_added eventdata
$eventdata = new object();
$eventdata->courseid = $modinstance->course;
$eventdata->itemmodule = $mod;
$eventdata->iteminstance = $modinstance->instance;
$eventdata->gradetype = 0;
$eventdata->itemid = $grade_item->id;
$eventdata->userid = $userid;
if ($scaleid) {
if ($usergrade == '-') {
// no grade
$eventdata->gradevalue = null;
} else if ($scaleid) {
// scale in use, words used
$gradescale = explode(",", $scale->scale);
$eventdata->gradevalue = array_search($usergrade, $gradescale) + 1;
} else {
// good old numeric value
$eventdata->gradevalue = $usergrade;
}
$eventdata->itemname = $modinstance->name;
$eventdata->grademax = $maxgrade;
$eventdata->scaleid = $scaleid;
events_trigger('grade_added', $eventdata);
events_trigger('grade_updated', $eventdata);
}
}
}
@ -255,6 +256,78 @@ function grades_grab_grades() {
}
}
/**
* Get (create if needed) grade item for legacy modules.
*/
function grade_get_legacy_grade_item($modinstance, $grademax, $scaleid) {
// does it already exist?
if ($grade_items = grade_get_items($modinstances->courseid, 'mod', $modinstance->modname, $modinstances->id)) {
if (count($grade_items) > 1) {
return false;
}
$grade_item = reset($grade_items);
$updated = false;
if ($scaleid) {
if ($grade_item->scaleid != $scaleid) {
$grade_item->gradetype = GRADE_TYPE_SCALE;
$grade_item->scaleid = $scaleid;
$updated = true;;
}
} else if ($grade_item->scaleid != $scaleid or $grade_item->grademax != $grademax) {
$grade_item->gradetype = GRADE_TYPE_VALUE;
$grade_item->scaleid = 0;
$grade_item->grademax = $grademax;
$grade_item->grademin = 0;
$updated = true;;
}
if ($grade_item->itemname != $modinstance->name) {
$grade_item->itemname = $modinstance->name;
$updated = true;;
}
if ($grade_item->idnumber != $modinstance->cmidnumber) {
$grade_item->idnumber = $modinstance->cmidnumber;
$updated = true;;
}
if ($updated) {
$grade_item->update();
}
return $grade_item;
}
// create new one
$params = array('courseid' =>$modinstance->courseid,
'itemtype' =>'mod',
'itemmodule' =>$modinstance->modname,
'iteminstance'=>$modinstance->id,
'itemname' =>$modinstance->name,
'idnumber' =>$modinstance->cmidnumber);
if ($scaleid) {
$params['gradetype'] = GRADE_TYPE_SCALE;
$params['scaleid'] = $scaleid;
} else {
$params['gradetype'] = GRADE_TYPE_VALUE;
$params['grademax'] = $grademax;
$params['grademin'] = 0;
}
if (!$itemid = grade_create_item($params)) {
return false;
}
return grade_item::fetch('id', $itemid);
}
/**
* Given a float value situated between a source minimum and a source maximum, converts it to the
* corresponding value situated between a target minimum and a target maximum. Thanks to Darlene
@ -284,7 +357,8 @@ function standardise_score($gradevalue, $source_min, $source_max, $target_min, $
/**
* Handles all grade_added and grade_updated events
* Handles all grade_updated and grade_updated_external events,
* see lib/db/events.php for description of $eventdata format.
*
* @param object $eventdata contains all the data for the event
* @return boolean success
@ -293,37 +367,25 @@ function standardise_score($gradevalue, $source_min, $source_max, $target_min, $
function grade_handler($eventdata) {
$eventdata = (array)$eventdata;
/// each grade must belong to some user
// each grade must belong to some user
if (empty($eventdata['userid'])) {
debugging('Missing user id in event data!');
return true;
}
/// First let's make sure a grade_item exists for this grade
if (!empty($eventdata['itemid'])) { // if itemid specified, do not use searching
$gradeitem = new grade_item(array('id'=>$eventdata['itemid']));
if (empty($gradeitem->id)) { // Item with itemid doesn't exist yet
debugging('grade_item does not exist! id:'.$eventdata['itemid']);
// this $eventadata can not be fixed, do not block the queue
// we should log the error somewhere on production servers
return true;
}
} else {
$gradeitem = new grade_item($eventdata);
if (empty($gradeitem->id)) { // Doesn't exist yet
if (!$gradeitem->id = $gradeitem->insert()) { // Try to create a new item...
debugging('Could not create a new grade_item!');
// do we need false here? - it would stop all other grades indefinitelly!
// we shouuld not IMO block other events, one silly bug in 3rd party module would disable all grading
// if we return false we must to notify admin and add some gui to fix the trouble
// skodak
return true; //for now
}
}
// grade item must be specified or else it could be accidentally duplicated,
if (empty($eventdata['itemid'])) {
debugging('Missing grade item id in event!');
return true;
}
// get the grade item from db
if (!$gradeitem = grade_item::fetch('id', $eventdata['itemid'])) {
debugging('Incorrect grade item id in event! id:'.$eventdata['itemid']);
return true;
}
// get the raw grade if it exist
$rawgrade = new grade_grades_raw(array('itemid'=>$gradeitem->id, 'userid'=>$eventdata['userid']));
$rawgrade->grade_item = &$gradeitem; // we already have it, so let's use it

2
lib/simpletest/fixtures/events.php

@ -24,7 +24,7 @@
///////////////////////////////////////////////////////////////////////////
$events = array (
$handlers = array (
'test_instant' => array (
'handlerfile' => '/lib/simpletest/testeventslib.php',
'handlerfunction' => 'sample_function_handler',

4
lib/simpletest/testeventslib.php

@ -106,9 +106,9 @@ class eventslib_test extends UnitTestCase {
global $CFG;
$dbcount = count_records('events_handlers', 'handlermodule', 'unittest');
$events = array();
$handlers = array();
require($CFG->libdir.'/simpletest/fixtures/events.php');
$filecount = count($events);
$filecount = count($handlers);
$this->assertEqual($dbcount, $filecount, 'Equal number of handlers in file and db: %s');
}

42
mod/assignment/db/events.php Normal file

@ -0,0 +1,42 @@
<?php // $Id$
///////////////////////////////////////////////////////////////////////////
// Defines core event handlers //
///////////////////////////////////////////////////////////////////////////
// //
// NOTICE OF COPYRIGHT //
// //
// Moodle - Modular Object-Oriented Dynamic Learning Environment //
// http://moodle.org //
// //
// Copyright (C) 1999 onwards Martin Dougiamas http://moodle.com //
// //
// This program is free software; you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation; either version 2 of the License, or //
// (at your option) any later version. //
// //
// This program is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details: //
// //
// http://www.gnu.org/copyleft/gpl.html //
// //
///////////////////////////////////////////////////////////////////////////
$handlers = array (
/*
* Grades created/modified outside of activities (import, gradebook overrides, etc.)
* see description in lib/db/events.php
*/
'grade_updated_external' => array (
'handlerfile' => '/mod/assignment/lib.php',
'handlerfunction' => array('assignment_base', 'external_grade_handler'),
'schedule' => 'instant'
)
);
?>

6
mod/assignment/db/upgrade.php

@ -32,7 +32,7 @@ function xmldb_assignment_upgrade($oldversion=0) {
$db->debug = false;
if ($rs->RecordCount() > 0) {
while ($assignment = rs_fetch_next_record($rs)) {
$item = grade_get_items($assignment->course, 'grade', 'mod', 'assignment', $assignment->id);
$item = grade_get_items($assignment->course, 'mod', 'assignment', $assignment->id);
if (!empty($item)) {
//already converted, it should not happen - probably interrupted upgrade?
continue;
@ -41,10 +41,10 @@ function xmldb_assignment_upgrade($oldversion=0) {
if ($rs2 = get_recordset('assignment_submissions', 'assignment', $assignment->id)) {
while ($sub = rs_fetch_next_record($rs2)) {
if ($sub->grade != -1 or !empty($sub->submissioncomment)) {
if ($sub->grade <0 ) {
if ($sub->grade < 0) {
$sub->grade = null;
}
events_trigger('grade_added', array('itemid'=>$itemid, 'gradevalue'=>$sub->grade, 'userid'=>$sub->userid, 'feedback'=>$sub->submissioncomment, 'feedbackformat'=>$sub->format));
events_trigger('grade_updated', array('itemid'=>$itemid, 'gradevalue'=>$sub->grade, 'userid'=>$sub->userid, 'feedback'=>$sub->submissioncomment, 'feedbackformat'=>$sub->format));
}
}
rs_close($rs2);

168
mod/assignment/lib.php

@ -471,7 +471,9 @@ class assignment_base {
// get existing grade item
$assignment = stripslashes_recursive($assignment);
$grade_item = assignment_base::get_grade_item($assignment);
$grade_item->itemname = $assignment->name;
$grade_item->idnumber = $assignment->cmidnumber;
if ($assignment->grade > 0) {
@ -503,16 +505,17 @@ class assignment_base {
* Static method - do not override!
*/
function create_grade_item($assignment) {
$params = array('courseid'=>$assignment->courseid,
'itemname'=>'assignment',
'itemtype'=>'mod',
'itemmodule'=>'assignment',
$params = array('courseid' =>$assignment->courseid,
'itemtype' =>'mod',
'itemmodule' =>'assignment',
'iteminstance'=>$assignment->id,
'idnumber'=>$assignment->cmidnumber);
'itemname' =>$assignment->name,
'idnumber' =>$assignment->cmidnumber);
if ($assignment->grade > 0) {
$params['gradetype'] = GRADE_TYPE_VALUE;
$params['grademax'] = $assignment->grade;
$params['grademin'] = 0;
} else if ($assignment->grade < 0) {
$params['gradetype'] = GRADE_TYPE_SCALE;
@ -535,11 +538,14 @@ class assignment_base {
* Final static method - do not override!
*/
function get_grade_item($assignment) {
if ($items = grade_get_items($assignment->courseid, NULL, 'mod', 'assignment', $assignment->id)) {
if ($items = grade_get_items($assignment->courseid, 'mod', 'assignment', $assignment->id)) {
if (count($items) > 1) {
debugging('Error - multiple assignment grading items present!');
}
$grade_item = reset($items);
return $grade_item;
}
// create new one
// create new one in case upgrade failed previously
if (!$itemid = assignment_base::create_grade_item($assignment)) {
error('Can not create grade item!');
}
@ -553,10 +559,100 @@ class assignment_base {
function update_grade($sid) {
$grade_item = assignment_base::get_grade_item($this->assignment);
$sub = get_record('assignment_submissions', 'id', $sid);
if ($sub->grade <0 ) {
if ($sub->grade < 0) {
$sub->grade = null;
}
events_trigger('grade_added', array('itemid'=>$grade_item->id, 'gradevalue'=>$sub->grade, 'userid'=>$sub->userid, 'feedback'=>$sub->submissioncomment, 'feedbackformat'=>$sub->format));
events_trigger('grade_updated', array('itemid'=>$grade_item->id, 'gradevalue'=>$sub->grade, 'userid'=>$sub->userid, 'feedback'=>$sub->submissioncomment, 'feedbackformat'=>$sub->format));
}
/**
* Something wants to change the grade from outside using "grade_updated_external" event.
* Final static method - do not override!
*
* see eventdata description in lib/db/events.php
*/
function external_grade_handler($eventdata) {
global $CFG, $USER;
$eventdata = (array)$eventdata;
// each grade must belong to some user
if (empty($eventdata['userid'])) {
debugging('Missing user id in event data!');
return true;
}
// grade item must be specified or else it could be accidentally duplicated,
if (empty($eventdata['itemid'])) {
debugging('Missing grade item id in event!');
return true;
}
// shortcut - try first without fetching the grade_item
if (!empty($eventdata['itemtype']) and !empty($eventdata['itemmodule'])) {
if ($eventdata['itemtype'] != 'mod' or $eventdata['itemmodule'] != 'assignment') {
// not our event
return true;
}
}
// get the grade item from db
if (!$grade_item = grade_item::fetch('id', $eventdata['itemid'])) {
debugging('Incorrect grade item id in event! id:'.$eventdata['itemid']);
return true;
}
//verify it is our event
if ($grade_item->itemtype != 'mod' or $grade_item->itemmodule != 'assignment') {
// not our event
return true;
}
if (!$assignment = get_record("assignment", "id", $grade_item->iteminstance)) {
return true;
}
if (! $course = get_record("course", "id", $assignment->course)) {
return true;
}
if (! $cm = get_coursemodule_from_instance("assignment", $assignment->id, $course->id)) {
return true;
}
// Load up the required assignment class
require($CFG->dirroot.'/mod/assignment/type/'.$assignment->assignmenttype.'/assignment.class.php');
$assignmentclass = 'assignment_'.$assignment->assignmenttype;
$assignmentinstance = new $assignmentclass($cm->id, $assignment, $cm, $course);
$sub = $assignmentinstance->get_submission((int)$eventdata['userid'], true); // Get or make one
$submission = new object();
$submission->id = $sub->id;
if (isset($eventdata['gradevalue'])) {
$submission->grade = (int)$eventdata['gradevalue'];
} else {
$submission->grade = -1;
}
if (isset($eventdata['feedback'])) {
$submission->submissioncomment = addslashes($eventdata['feedback']);
if (isset($eventdata['feedbackformat'])) {
$submission->format = (int)$eventdata['feedbackformat'];
} else {
$submission->format = FORMAT_PLAINTEXT;
}
}
$submission->teacher = $USER->id;
$submission->mailed = 0; // Make sure mail goes out (again, even)
$submission->timemarked = time();
update_record('assignment_submissions', $submission);
// TODO: add proper logging
add_to_log($course->id, 'assignment', 'update grades',
'submissions.php?id='.$assignment->id.'&user='.$submission->userid, $submission->userid, $cm->id);
return true;
}
/**
@ -1886,60 +1982,6 @@ function assignment_cron () {
return true;
}
/**
* Return an array of grades, indexed by user, and a max grade.
*
* @param $assignmentid int
* @return object with properties ->grades (an array of grades) and ->maxgrade.
*/
function assignment_grades($assignmentid) {
if (!$assignment = get_record('assignment', 'id', $assignmentid)) {
return NULL;
}
if ($assignment->grade == 0) { // No grading
return NULL;
}
$grades = get_records_menu('assignment_submissions', 'assignment',
$assignment->id, '', 'userid,grade');
$return = new object();
if ($assignment->grade > 0) {
if ($grades) {
foreach ($grades as $userid => $grade) {
if ($grade == -1) {
$grades[$userid] = '-';
}
}
}
$return->grades = $grades;
$return->maxgrade = $assignment->grade;
} else { // Scale
if ($grades) {
$scaleid = - ($assignment->grade);
$maxgrade = "";
if ($scale = get_record('scale', 'id', $scaleid)) {
$scalegrades = make_menu_from_list($scale->scale);
foreach ($grades as $userid => $grade) {
if (empty($scalegrades[$grade])) {
$grades[$userid] = '-';
} else {
$grades[$userid] = $scalegrades[$grade];
}
}
$maxgrade = $scale->name;
}
}
$return->grades = $grades;
$return->maxgrade = $maxgrade;
}
return $return;
}
/**
* Returns the users with data in one assignment (students and teachers)
*

4
mod/assignment/version.php

@ -5,8 +5,8 @@
// This fragment is called by /admin/index.php
////////////////////////////////////////////////////////////////////////////////
$module->version = 2007052700;
$module->requires = 2007052700; // Requires this Moodle version
$module->version = 2007052800;
$module->requires = 2007052800; // Requires this Moodle version
$module->cron = 60;
?>

361
tags

File diff suppressed because it is too large Load Diff

2
version.php

@ -6,7 +6,7 @@
// This is compared against the values stored in the database to determine
// whether upgrades should be performed (see lib/db/*.php)
$version = 2007052700; // YYYYMMDD = date
$version = 2007052800; // YYYYMMDD = date
// XY = increments within a single day
$release = '1.9 dev'; // Human-friendly version name