course)) {
error("Course is misconfigured");
}
if ($scales = get_records("scale", "courseid", $course->id, "name ASC")) {
foreach ($scales as $scale) {
$labels = explode(",", $scale->scale);
$EXERCISE_SCALES[] = array('name' => $scale->name, 'type' => 'radio', 'size' => count($labels),
'start' => trim($labels[0]), 'end' => trim($labels[count($labels) - 1]));
}
}
return;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_compare_assessments($exercise, $assessment1, $assessment2) {
global $EXERCISE_ASSESSMENT_COMPS, $EXERCISE_EWEIGHTS;
// first get the assignment elements for maxscores...
$elementsraw = get_records("exercise_elements", "exerciseid", $exercise->id, "elementno ASC");
foreach ($elementsraw as $element) {
$maxscore[] = $element->maxscore; // to renumber index 0,1,2...
$weight[] = $EXERCISE_EWEIGHTS[$element->weight]; // get real value and renumber index 0,1,2...
}
for ($i = 0; $i < 2; $i++) {
if ($i) {
$rawgrades = get_records("exercise_grades", "assessmentid", $assessment1->id, "elementno ASC");
} else {
$rawgrades = get_records("exercise_grades", "assessmentid", $assessment2->id, "elementno ASC");
}
foreach ($rawgrades as $grade) {
$grades[$i][] = $grade->grade;
}
}
$sumdiffs = 0;
$sumweights = 0;
switch ($exercise->gradingstrategy) {
case 1 : // accumulative grading and...
case 4 : // ...rubic grading
for ($i=0; $i < $exercise->nelements; $i++) {
$diff = ($grades[0][$i] - $grades[1][$i]) * $weight[$i] / $maxscore[$i];
$sumdiffs += $diff * $diff; // use squared distances
$sumweights += $weight[$i];
}
break;
case 2 : // error banded grading
// ignore maxscores here, the grades are either 0 or 1,
for ($i=0; $i < $exercise->nelements; $i++) {
$diff = ($grades[0][$i] - $grades[1][$i]) * $weight[$i];
$sumdiffs += $diff * $diff; // use squared distances
$sumweights += $weight[$i];
}
break;
case 3 : // criterion grading
// here we only need to look at the difference between the "zero" grade elements
$diff = ($grades[0][0] - $grades[1][0]) / (count($elementsraw) - 1);
$sumdiffs = $diff * $diff;
$sumweights = 1;
break;
}
// convert to a sensible grade (always out of 100)
$COMP = (object)$EXERCISE_ASSESSMENT_COMPS[$exercise->assessmentcomps];
$factor = $COMP->value;
$gradinggrade = (($factor - ($sumdiffs / $sumweights)) / $factor) * 100;
if ($gradinggrade < 0) {
$gradinggrade = 0;
}
return $gradinggrade;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_copy_assessment($assessment, $submission, $withfeedback = false) {
// adds a copy of the given assessment for the submission specified to the exercise_assessemnts table.
// The grades and optionally the comments are added to the exercise_grades table. Returns the new
// assessment object
global $USER;
$yearfromnow = time() + 365 * 86400;
$newassessment->exerciseid = $assessment->exerciseid;
$newassessment->submissionid = $submission->id;
$newassessment->userid = $USER->id;
$newassessment->timecreated = $yearfromnow;
$newassessment->timegraded = 0;
$newassessment->grade = $assessment->grade;
if ($withfeedback) {
$newassessment->generalcomment = addslashes($assessment->generalcomment);
$newassessment->teachercomment = addslashes($assessment->teachercomment);
}
if (!$newassessment->id = insert_record("exercise_assessments", $newassessment)) {
error("Copy Assessment: Could not insert exercise assessment!");
}
if ($grades = get_records("exercise_grades", "assessmentid", $assessment->id)) {
foreach ($grades as $grade) {
unset($grade->id); // clear id, insert record now seems to believe it!
if (!$withfeedback) {
$grade->feedback = '';
}
else {
$grade->feedback = addslashes($grade->feedback);
// $grade->feedback = $grade->feedback;
}
$grade->assessmentid = $newassessment->id;
if (!$grade->id = insert_record("exercise_grades", $grade)) {
error("Copy Assessment: Could not insert exercise grade!");
}
}
}
if ($withfeedback) {
// remove the slashes from comments as the new assessment record is used
// in assessments and in lib
$newassessment->generalcomment = stripslashes($assessment->generalcomment);
$newassessment->teachercomment = stripslashes($assessment->teachercomment);
}
return $newassessment;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_all_submissions_for_assessment($exercise, $user) {
// looks at all submissions and deducts the number which has been assessed by this user
$n = 0;
if ($submissions = get_records_select("exercise_submissions", "exerciseid = $exercise->id AND timecreated > 0")) {
$n =count($submissions);
foreach ($submissions as $submission) {
$n -= count_records("exercise_assessments", "submissionid", $submission->id, "userid", $user->id);
}
}
return $n;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_assessments($submission) {
// Return the (cold) assessments for this submission,
global $CFG;
$timethen = time() - $CFG->maxeditingtime;
return count_records_select("exercise_assessments", "submissionid = $submission->id AND
timecreated < $timethen");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_assessments_by_teacher($exercise, $teacher) {
// Return the number of assessments done by a teacher
return count_records_select("exercise_assessments", "exerciseid = $exercise->id AND
userid = $teacher->id");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_student_submissions($exercise) {
global $CFG;
// make sure it works on the site course
$select = "u.course = '$exercise->course' AND";
if ($exercise->course == SITEID) {
$select = '';
}
return count_records_sql("SELECT count(*) FROM {$CFG->prefix}exercise_submissions s, {$CFG->prefix}user_students u
WHERE $select s.userid = u.userid
AND s.exerciseid = $exercise->id
AND timecreated > 0");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_teacher_assessments($exercise, $user) {
// returns the number of assessments made by teachers on user's submissions
$n = 0;
if ($submissions = exercise_get_user_submissions($exercise, $user)) {
foreach ($submissions as $submission) {
if ($assessments = exercise_get_assessments($submission)) {
foreach ($assessments as $assessment) {
// count only teacher assessments
if (isteacher($exercise->course, $assessment->userid)) {
$n++;
}
}
}
}
}
return $n;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_teacher_submissions($exercise) {
return count_records("exercise_submissions", "isexercise", 1, "exerciseid", $exercise->id);
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_teacher_submissions_for_assessment($exercise, $user) {
$n = 0;
if ($submissions = exercise_get_teacher_submissions($exercise)) {
$n =count($submissions);
foreach ($submissions as $submission) {
$n -= count_records("exercise_assessments", "submissionid", $submission->id, "userid", $user->id);
}
}
return $n;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_unassessed_student_submissions($exercise) {
// returns the number of students submissions which have not been assessed by a teacher
global $CFG;
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
$timenow = time();
$n = 0;
// look at all the student submissions, exercise_get_student_submissions is group aware
$groupid = get_current_group($course->id);
if ($submissions = exercise_get_student_submissions($exercise, "time", $groupid)) {
foreach ($submissions as $submission) {
// only look at "cold" submissions
if ($submission->timecreated < $timenow - $CFG->maxeditingtime) {
$teacherassessed = false;
if ($assessments = exercise_get_assessments($submission)) {
foreach ($assessments as $assessment) {
// exercise_get_assessments only returns "cold" assessments, look for one made by a teacher
if (isteacher($course->id, $assessment->userid)) {
$teacherassessed = true;
break; // no need to look further
}
}
}
if (!$teacherassessed) {
$n++;
}
}
}
}
return $n;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_ungraded_assessments_student($exercise, $groupid = 0) {
// function returns the number of ungraded assessments by students of STUDENT submissions
$n = 0;
if ($submissions = exercise_get_student_submissions($exercise, $groupid)) {
foreach ($submissions as $submission) {
if ($assessments = exercise_get_assessments($submission)) {
foreach ($assessments as $assessment) {
if ($assessment->timegraded == 0) {
// ignore teacher assessments
if (!isteacher($exercise->course, $assessment->userid)) {
$n++;
}
}
}
}
}
}
return $n;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_ungraded_assessments_teacher($exercise) {
// function returns the number of ungraded assessments by students of TEACHER submissions
global $CFG;
$timenow = time();
$n = 0;
if ($submissions = exercise_get_teacher_submissions($exercise)) {
foreach ($submissions as $submission) {
if ($assessments = exercise_get_assessments($submission)) {
foreach ($assessments as $assessment) {
if ($assessment->timegraded == 0) {
// ignore teacher assessments
if (!isteacher($exercise->course, $assessment->userid)) {
// must have created a little time ago
if (($timenow - $assessment->timecreated) > $CFG->maxeditingtime) {
$n++;
}
}
}
}
}
}
}
return $n;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_user_assessments($exercise, $user, $stype = "all") {
// returns the number of assessments allocated/made by a user, all of them, or just those for the student or teacher submissions
// the student's self assessments are included in the count
// the maxeditingtime is NOT taken into account here also allocated assessments which have not yet
// been done are counted as well
$n = 0;
if ($assessments = exercise_get_user_assessments($exercise, $user)) {
foreach ($assessments as $assessment) {
switch ($stype) {
case "all" :
$n++;
break;
case "student" :
$submission = get_record("exercise_submissions", "id", $assessment->submissionid);
if (isstudent($exercise->course, $submission->userid)) {
$n++;
}
break;
case "teacher" :
$submission = get_record("exercise_submissions", "id", $assessment->submissionid);
if (isteacher($exercise->course, $submission->userid)) {
$n++;
}
break;
}
}
}
return $n;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_user_assessments_done($exercise, $user) {
// returns the number of assessments actually done by a user
// the student's self assessments are included in the count
// the maxeditingtime is NOT taken into account here
$n = 0;
$timenow = time();
if ($assessments = exercise_get_user_assessments($exercise, $user)) {
foreach ($assessments as $assessment) {
if ($assessment->timecreated < $timenow) {
$n++;
}
}
}
return $n;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_count_user_submissions($exercise, $user) {
// returns the number of submissions make by this user
return count_records("exercise_submissions", "exerciseid", $exercise->id, "userid", $user->id);
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_delete_submitted_files($exercise, $submission) {
// Deletes the files in the exercise area for this submission
if ($basedir = exercise_file_area($exercise, $submission)) {
if ($files = get_directory_list($basedir)) {
foreach ($files as $file) {
if (unlink("$basedir/$file")) {
notify("Existing file '$file' has been deleted!");
}
else {
notify("Attempt to delete file $basedir/$file has failed!");
}
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_delete_user_files($exercise, $user, $exception) {
// Deletes all the user files in the exercise area for a user
// EXCEPT for any file named $exception
if (!$submissions = exercise_get_submissions($exercise, $user)) {
notify("No submissions!");
return;
}
foreach ($submissions as $submission) {
if ($basedir = exercise_file_area($exercise, $submission)) {
if ($files = get_directory_list($basedir)) {
foreach ($files as $file) {
if ($file != $exception) {
unlink("$basedir/$file");
notify("Existing file '$file' has been deleted!");
}
}
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_get_best_submission_grades($exercise) {
// Returns the grades of students' best submissions
global $CFG;
// make sure it works on the site course
$select = "u.course = '$exercise->course' AND";
if ($exercise->course == SITEID) {
$select = '';
}
return get_records_sql("SELECT DISTINCT u.userid, MAX(a.grade) AS grade FROM
{$CFG->prefix}exercise_submissions s,
{$CFG->prefix}exercise_assessments a, {$CFG->prefix}user_students u
WHERE $select s.userid = u.userid
AND s.exerciseid = $exercise->id
AND s.late = 0
AND a.submissionid = s.id
GROUP BY u.userid");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_get_mean_grade($submission) {
// Returns the mean grade of students' submission (may, very occassionally, be more than one assessment)
global $CFG;
return get_record_sql("SELECT AVG(a.grade) AS grade FROM
{$CFG->prefix}exercise_assessments a
WHERE a.submissionid = $submission->id
GROUP BY a.submissionid");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_get_student_submission($exercise, $user) {
// Return a submission for a particular user
global $CFG;
$submission = get_record("exercise_submissions", "exerciseid", $exercise->id, "userid", $user->id);
if (!empty($submission->timecreated)) {
return $submission;
}
return NULL;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_get_student_submissions($exercise, $order = "time", $groupid = 0) {
// Return all ENROLLED student submissions
// if order can grade|title|name|nothing, nothing is oldest first, youngest last
global $CFG;
if ($groupid) {
// just look at a single group
if ($order == "grade") {
// allow for multiple assessments of submissions (coming from different teachers)
// make sure it works on the site course
$select = "u.course = '$exercise->course' AND";
if ($exercise->course == SITEID) {
$select = '';
}
return get_records_sql("SELECT s.*, AVG(a.grade) AS grade FROM {$CFG->prefix}user_students u,
{$CFG->prefix}groups_members g, {$CFG->prefix}exercise_submissions s,
{$CFG->prefix}exercise_assessments a
WHERE $select g.groupid = $groupid
AND u.userid = g.userid
AND s.userid = u.userid
AND s.exerciseid = $exercise->id
AND a.submissionid = s.id
GROUP BY s.id
ORDER BY a.grade DESC");
}
if ($order == "title") {
$order = "s.title";
} elseif ($order == "name") {
$order = "n.firstname, n.lastname, s.timecreated DESC";
} elseif ($order == "time") {
$order = "s.timecreated";
}
// make sure it works on the site course
$select = "u.course = '$exercise->course' AND";
if ($exercise->course == SITEID) {
$select = '';
}
return get_records_sql("SELECT s.* FROM {$CFG->prefix}user_students u, {$CFG->prefix}user n,
{$CFG->prefix}groups_members g, {$CFG->prefix}exercise_submissions s
WHERE $select g.groupid = $groupid
AND u.userid = g.userid
AND s.userid = u.userid
AND n.id = u.userid
AND s.exerciseid = $exercise->id
ORDER BY $order");
}
else { // no group - all users
if ($order == "grade") {
// allow for multiple assessments of submissions (coming from different teachers)
// make sure it works on the site course
$select = "u.course = '$exercise->course' AND";
if ($exercise->course == SITEID) {
$select = '';
}
return get_records_sql("SELECT s.*, AVG(a.grade) AS grade FROM {$CFG->prefix}exercise_submissions s,
{$CFG->prefix}user_students u, {$CFG->prefix}exercise_assessments a
WHERE $select s.userid = u.userid
AND s.exerciseid = $exercise->id
AND a.submissionid = s.id
GROUP BY s.id
ORDER BY a.grade DESC");
}
if ($order == "title") {
$order = "s.title";
} elseif ($order == "name") {
$order = "n.firstname, n.lastname, s.timecreated DESC";
} elseif ($order == "time") {
$order = "s.timecreated";
}
// make sure it works on the site course
$select = "u.course = '$exercise->course' AND";
if ($exercise->course == SITEID) {
$select = '';
}
return get_records_sql("SELECT s.* FROM {$CFG->prefix}exercise_submissions s,
{$CFG->prefix}user_students u, {$CFG->prefix}user n
WHERE $select s.userid = u.userid
AND n.id = u.userid
AND s.exerciseid = $exercise->id
ORDER BY $order");
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_get_submission_assessment($submission, $user = null) {
// Return a user's assessment for this submission
if ($user) {
return get_record("exercise_assessments", "submissionid", $submission->id, "userid", $user->id);
} else { // likely to be the teacher's assessment
return get_record("exercise_assessments", "submissionid", $submission->id);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_get_teacher_submissions($exercise) {
// Return all teacher submissions, ordered by title
global $CFG;
return get_records_sql("SELECT s.* FROM {$CFG->prefix}exercise_submissions s
WHERE s.isexercise = 1
AND s.exerciseid = $exercise->id
ORDER BY s.title");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_get_ungraded_assessments($exercise) {
global $CFG;
// Return all assessments which have not been graded or just graded
$cutofftime =time() - $CFG->maxeditingtime;
return get_records_select("exercise_assessments", "exerciseid = $exercise->id AND (timegraded = 0 OR
timegraded > $cutofftime)", "timecreated");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_get_ungraded_assessments_student($exercise) {
global $CFG;
// Return all assessments which have not been graded or just graded of student's submissions
// make sure it works on the site course
$select = "u.course = '$exercise->course' AND";
if ($exercise->course == SITEID) {
$select = '';
}
$cutofftime =time() - $CFG->maxeditingtime;
return get_records_sql("SELECT a.* FROM {$CFG->prefix}exercise_submissions s, {$CFG->prefix}user_students u,
{$CFG->prefix}exercise_assessments a
WHERE $select s.userid = u.userid
AND s.exerciseid = $exercise->id
AND a.submissionid = s.id
AND (a.timegraded = 0 OR a.timegraded > $cutofftime)
AND a.timecreated < $cutofftime
ORDER BY a.timecreated ASC");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_get_ungraded_assessments_teacher($exercise) {
global $CFG;
// Return all assessments which have not been graded or just graded of teacher's submissions
$cutofftime =time() - $CFG->maxeditingtime;
return get_records_sql("SELECT a.* FROM {$CFG->prefix}exercise_submissions s, {$CFG->prefix}exercise_assessments a
WHERE s.isexercise = 1
AND s.exerciseid = $exercise->id
AND a.submissionid = s.id
AND (a.timegraded = 0 OR a.timegraded > $cutofftime)
AND a.timecreated < $cutofftime
ORDER BY a.timecreated ASC");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_get_user_assessments($exercise, $user) {
// Return all the user's assessments, newest first, oldest last
// students will have only one, teachers will have more...
return get_records_select("exercise_assessments", "exerciseid = $exercise->id AND userid = $user->id",
"timecreated DESC");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_list_all_ungraded_assessments($exercise) {
// lists all the assessments for comment by teacher
global $CFG;
$table->head = array (get_string("title", "exercise"), get_string("timeassessed", "exercise"), get_string("action", "exercise"));
$table->align = array ("left", "left", "left");
$table->size = array ("*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
$timenow = time();
if ($assessments = exercise_get_ungraded_assessments($exercise)) {
foreach ($assessments as $assessment) {
if (!isteacher($exercise->course, $assessment->userid)) {
if (($timenow - $assessment->timegraded) < $CFG->maxeditingtime) {
$action = "id&aid=$assessment->id\">".
get_string("edit", "exercise")."";
}
else {
$action = "id&aid=$assessment->id\">".
get_string("gradeassessment", "exercise")."";
}
$submission = get_record("exercise_submissions", "id", $assessment->submissionid);
$table->data[] = array(exercise_print_submission_title($exercise, $submission),
userdate($assessment->timecreated), $action);
}
}
if (isset($table->data)) {
print_table($table);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_list_submissions_for_admin($exercise) {
// list the teacher sublmissions first
global $CFG, $THEME, $USER;
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
$groupid = get_current_group($course->id);
exercise_print_assignment_info($exercise);
print_heading_with_help(get_string("administration"), "administration", "exercise");
echo"id\">".
get_string("teacherassessmenttable", "exercise", $course->teacher)."
\n";
if (isteacheredit($course->id)) {
// list any teacher submissions
$table->head = array (get_string("title", "exercise"), get_string("submitted", "exercise"),
get_string("action", "exercise"));
$table->align = array ("left", "left", "left");
$table->size = array ("*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
if ($submissions = exercise_get_teacher_submissions($exercise)) {
foreach ($submissions as $submission) {
$action = "id&sid=$submission->id\">".
get_string("amendtitle", "exercise")."";
if (isteacheredit($course->id)) {
$action .= " | id&sid=$submission->id\">".
get_string("delete", "exercise")."";
}
$table->data[] = array(exercise_print_submission_title($exercise, $submission),
userdate($submission->timecreated), $action);
}
print_heading(get_string("studentsubmissions", "exercise", $course->teacher), "center");
print_table($table);
}
}
// list student assessments
// Get all the students...
if ($users = get_course_students($course->id, "u.lastname, u.firstname")) {
$timenow = time();
unset($table);
$table->head = array(get_string("name"), get_string("title", "exercise"),
get_string("assessed", "exercise"), get_string("action", "exercise"));
$table->align = array ("left", "left", "left", "left");
$table->size = array ("*", "*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
$nassessments = 0;
foreach ($users as $user) {
// check group membership, if necessary
if ($groupid) {
// check user's group
if (!ismember($groupid, $user->id)) {
continue; // skip this user
}
}
if ($assessments = exercise_get_user_assessments($exercise, $user)) {
$title ='';
foreach ($assessments as $assessment) {
if (!$submission = get_record("exercise_submissions", "id", $assessment->submissionid)) {
error("exercise_list_submissions_for_admin: Submission record not found!");
}
$title .= $submission->title;
// test for allocated assesments which have not been done
if ($assessment->timecreated < $timenow) {
// show only warm or cold assessments
$title .= " {".number_format($assessment->grade * $exercise->grade / 100.0, 0);
if ($assessment->timegraded) {
$title .= "/".number_format($assessment->gradinggrade * $exercise->gradinggrade / 100.0, 0);
}
$title .= "} ";
if ($realassessments = exercise_count_user_assessments_done($exercise, $user)) {
$action = "id&userid=$user->id\">".
get_string("view", "exercise")."";
}
else {
$action ="";
}
$nassessments++;
$table->data[] = array(fullname($user), $title,
userdate($assessment->timecreated), $action);
}
}
}
}
if (isset($table->data)) {
if ($groupid) {
if (!$group = get_record("groups", "id", $groupid)) {
error("List unassessed student submissions: group not found");
}
print_heading("$group->name ".get_string("studentassessments", "exercise", $course->student).
" [$nassessments]");
} else {
print_heading(get_string("studentassessments", "exercise", $course->student)." [$nassessments]");
}
print_table($table);
echo "".get_string("noteonstudentassessments", "exercise");
echo "
{".get_string("maximumgrade").": $exercise->grade / ".
get_string("maximumgrade").": $exercise->gradinggrade}
\n";
// grading grade analysis
unset($table);
$table->head = array (get_string("count", "exercise"), get_string("mean", "exercise"),
get_string("standarddeviation", "exercise"), get_string("maximum", "exercise"),
get_string("minimum", "exercise"));
$table->align = array ("center", "center", "center", "center", "center");
$table->size = array ("*", "*", "*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
if ($groupid) {
$stats = get_record_sql("SELECT COUNT(*) as count, AVG(gradinggrade) AS mean,
STDDEV(gradinggrade) AS stddev, MIN(gradinggrade) AS min, MAX(gradinggrade) AS max
FROM {$CFG->prefix}groups_members g, {$CFG->prefix}exercise_assessments a
WHERE g.groupid = $groupid AND a.userid = g.userid AND a.timegraded > 0
AND a.exerciseid = $exercise->id");
} else { // no group/all participants
$stats = get_record_sql("SELECT COUNT(*) as count, AVG(gradinggrade) AS mean,
STDDEV(gradinggrade) AS stddev, MIN(gradinggrade) AS min, MAX(gradinggrade) AS max
FROM {$CFG->prefix}exercise_assessments a
WHERE a.timegraded > 0 AND a.exerciseid = $exercise->id");
}
$table->data[] = array($stats->count, number_format($stats->mean * $exercise->gradinggrade / 100.0, 1),
number_format($stats->stddev * $exercise->gradinggrade / 100.0, 1),
number_format($stats->max * $exercise->gradinggrade / 100.0, 1),
number_format($stats->min * $exercise->gradinggrade / 100.0, 1));
print_heading(get_string("gradinggrade", "exercise")." ".get_string("analysis", "exercise"));
print_table($table);
echo "id&action=regradestudentassessments\">".
get_string("regradestudentassessments", "exercise")." ";
helpbutton("regrading", get_string("regradestudentassessments", "exercise"), "exercise");
echo "
\n";
}
}
// now the sudent submissions
unset($table);
if ($users) {
$table->head = array (get_string("submittedby", "exercise"), get_string("title", "exercise"),
get_string("submitted", "exercise"), get_string("action", "exercise"));
$table->align = array ("left", "left", "left", "left");
$table->size = array ("*", "*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
$nsubmissions = 0;
foreach ($users as $user) {
// check group membership, if necessary
if ($groupid) {
// check user's group
if (!ismember($groupid, $user->id)) {
continue; // skip this user
}
}
if ($submissions = exercise_get_user_submissions($exercise, $user)) {
foreach ($submissions as $submission) {
$action = "id&sid=$submission->id\">".
get_string("amendtitle", "exercise")."";
// has teacher already assessed this submission
if ($assessment = get_record_select("exercise_assessments",
"submissionid = $submission->id AND userid = $USER->id")) {
$curtime = time();
if (($curtime - $assessment->timecreated) > $CFG->maxeditingtime) {
$action .= " | id&sid=$submission->id\">".
get_string("reassess", "exercise")."";
}
else { // there's still time left to edit...
$action .= " | id&sid=$submission->id\">".
get_string("edit", "exercise")."";
}
}
else { // user has not assessed this submission
$action .= " | id&sid=$submission->id\">".
get_string("assess", "exercise")."";
}
if ($nassessments = exercise_count_assessments($submission)) {
$action .= " | id&sid=$submission->id\">".
get_string("view", "exercise")." ($nassessments)";
}
if ($submission->late) {
$action .= " | id&sid=$submission->id\">".
get_string("clearlateflag", "exercise")."";
}
$action .= " | id&sid=$submission->id\">".
get_string("delete", "exercise")."";
$title = $submission->title;
if ($submission->resubmit) {
$title .= "*";
}
$datesubmitted = userdate($submission->timecreated);
if ($submission->late) {
$datesubmitted = "".$datesubmitted."";
}
$table->data[] = array(fullname($user), $title.
" ".exercise_print_submission_assessments($exercise, $submission),
$datesubmitted, $action);
$nsubmissions++;
}
}
}
if (isset($table->data)) {
if ($groupid) {
if (!$group = get_record("groups", "id", $groupid)) {
error("List unassessed student submissions: group not found");
}
print_heading("$group->name ".get_string("studentsubmissions", "exercise", $course->student).
" [$nsubmissions]");
} else {
print_heading(get_string("studentsubmissions", "exercise", $course->student)." [$nsubmissions]",
"center");
}
print_table($table);
echo "[] - ".get_string("gradeforsubmission", "exercise");
echo "
".get_string("maximumgrade").": $exercise->grade
\n";
echo "".get_string("resubmitnote", "exercise", $course->student)."
\n";
// grade analysis
unset($table);
$table->head = array (get_string("count", "exercise"), get_string("mean", "exercise"),
get_string("standarddeviation", "exercise"), get_string("maximum", "exercise"),
get_string("minimum", "exercise"));
$table->align = array ("center", "center", "center", "center", "center");
$table->size = array ("*", "*", "*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
if ($groupid) {
$stats = get_record_sql("SELECT COUNT(*) as count, AVG(grade) AS mean,
STDDEV(grade) AS stddev, MIN(grade) AS min, MAX(grade) AS max
FROM {$CFG->prefix}groups_members g, {$CFG->prefix}exercise_assessments a,
{$CFG->prefix}exercise_submissions s, {$CFG->prefix}user_teachers t
WHERE g.groupid = $groupid AND s.userid = g.userid AND a.submissionid = s.id
AND a.userid = t.userid AND a.exerciseid = $exercise->id");
} else { // no group/all participants
$stats = get_record_sql("SELECT COUNT(*) as count, AVG(grade) AS mean,
STDDEV(grade) AS stddev, MIN(grade) AS min, MAX(grade) AS max
FROM {$CFG->prefix}exercise_assessments a, {$CFG->prefix}user_teachers t
WHERE a.userid = t.userid AND a.exerciseid = $exercise->id");
}
$table->data[] = array($stats->count, number_format($stats->mean * $exercise->grade / 100.0, 1),
number_format($stats->stddev * $exercise->grade / 100.0, 1),
number_format($stats->max * $exercise->grade / 100.0, 1),
number_format($stats->min * $exercise->grade / 100.0, 1));
print_heading(get_string("grade")." ".get_string("analysis", "exercise"));
print_table($table);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_list_teacher_assessments($exercise, $user) {
global $CFG;
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
$table->head = array (get_string("title", "exercise"), get_string("action", "exercise"), get_string("comment", "exercise"));
$table->align = array ("left", "left", "left");
$table->size = array ("*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
// get user's submissions
if ($submissions = exercise_get_user_submissions($exercise, $user)) {
foreach ($submissions as $submission) {
// get the assessments
if ($assessments = exercise_get_assessments($submission)) {
foreach ($assessments as $assessment) {
if (isteacher($exercise->course, $assessment->userid)) { // assessments by teachers only
$action = "id&aid=$assessment->id\">".
get_string("view", "exercise")."";
// has teacher commented on teacher's assessment? shouldn't happen but leave test in
if ($assessment->timegraded and ($timenow - $assessment->timegraded > $CFG->maxeditingtime)) {
$comment = get_string("gradedbyteacher", "exercise", $course->teacher);
}
else {
$comment = userdate($assessment->timecreated);
}
$table->data[] = array(exercise_print_submission_title($exercise, $submission), $action, $comment);
}
}
}
}
}
if (isset($table->data)) {
print_table($table);
}
else {
echo "".get_string("noassessmentsdone", "exercise")."\n";
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_list_teacher_submissions($exercise, $user, $reassess = false) {
// always allow user to reassess if that flag is true
global $CFG;
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
$strexercises = get_string("modulenameplural", "exercise");
$strexercise = get_string("modulename", "exercise");
// get any assessment this user has done (could include hot one)
if (!$assessment = get_record_select("exercise_assessments", "exerciseid = $exercise->id
AND userid = $user->id")) {
// the user has not yet assessed this exercise, set up a hot assessment record for this user for one
// of the teacher submissions, first count the number of assessments for each teacher submission...
if ($submissions = exercise_get_teacher_submissions($exercise)) {
// mt_srand ((float)microtime()*1000000); // initialise random number generator, assume php>=4.2.0
foreach ($submissions as $submission) {
$n = count_records("exercise_assessments", "submissionid", $submission->id);
// ...OK to have zero, we add a small random number to randomise things...
$nassessments[$submission->id] = $n + mt_rand(0, 99) / 100;
}
// ...put the submissions with the lowest number of assessments first...
asort($nassessments);
reset($nassessments);
foreach ($nassessments as $submissionid => $n) { // break out of loop after the first element
$submission = get_record("exercise_submissions", "id", $submissionid);
// ... provided the user has NOT already assessed that submission...
if (!$assessment = exercise_get_submission_assessment($submission, $user)) {
$yearfromnow = time() + 365 * 86400;
// ...create one and set timecreated way in the future, reset when record is updated
$assessment->exerciseid = $exercise->id;
$assessment->submissionid = $submission->id;
$assessment->userid = $user->id;
$assessment->grade = -1; // set impossible grade
$assessment->timecreated = $yearfromnow;
$assessment->mailed = 1; // no need to email to the teacher!
if (!$assessment->id = insert_record("exercise_assessments", $assessment)) {
error("Could not insert exercise assessment!");
}
break;
}
}
}
} else {
// get hold of the teacher submission
if (!$submission = get_record("exercise_submissions", "id", $assessment->submissionid)) {
error("List teacher submissions: submission record not found");
}
}
print_simple_box_start("center");
print_heading_with_help(get_string("theexercise", "exercise"), "junk", "exercise");
print_simple_box_start("center");
echo "".get_string("description", "exercise").": \n";
echo exercise_print_submission_title($exercise, $submission);
echo "
\n";
print_simple_box_end();
print_simple_box_end();
$table->head = array (get_string("action", "exercise"), get_string("assessed", "exercise"),
get_string("comment", "exercise"));
$table->align = array ("left", "left", "left");
$table->size = array ("*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
// now list user's assessments (but only list those which come from teacher submissions)
print_heading(get_string("yourassessment", "exercise"));
$assessed = false;
if ($assessments = exercise_get_user_assessments($exercise, $user)) {
$timenow = time();
foreach ($assessments as $assessment) {
if (!$submission = get_record("exercise_submissions", "id", $assessment->submissionid)) {
error ("exercise_list_teacher_submissions: unable to get submission");
}
// submission from a teacher, i.e an exercise submission?
if ($submission->isexercise) {
$comment = '';
if ($reassess) { // just show re-assess
$action = "id&sid=$submission->id\">".
get_string("reassess", "exercise")."";
}
else { // reassess is false - assessment is a "normal state"
// user assessment has three states: record created but not assessed (date created
// in the future); just assessed but still editable; and "static" (may or may not
// have been graded by teacher, that is shown in the comment)
if ($assessment->timecreated > $timenow) { // user needs to assess this submission
$action = "id&sid=$submission->id\">".
get_string("assess", "exercise")."";
}
elseif ($assessment->timecreated > ($timenow - $CFG->maxeditingtime)) {
// there's still time left to edit...
$action = "id&sid=$submission->id\">".
get_string("edit", "exercise")."";
}
else {
$action = "id&aid=$assessment->id\">"
.get_string("view", "exercise")."";
}
}
// show the date if in the past (otherwise the user hasn't done the assessment yet
$assessmentdate = '';
if ($assessment->timecreated < $timenow) {
$assessmentdate = userdate($assessment->timecreated);
// if user has submitted work, see if teacher has graded assessment
if (exercise_count_user_submissions($exercise, $user) > 0) {
if ($assessment->timegraded and (($timenow - $assessment->timegraded) > $CFG->maxeditingtime)) {
$comment .= get_string("gradeforassessment", "exercise").": ".
number_format($assessment->gradinggrade * $exercise->gradinggrade / 100.0, 1).
" (".get_string("maximumgrade")." ".number_format($exercise->gradinggrade, 0).")";
$assessed = true;
}
else {
$comment .= get_string("awaitingassessmentbythe", "exercise", $course->teacher);
}
}
}
$table->data[] = array($action, $assessmentdate, $comment);
}
}
print_table($table);
if ($assessed) {
echo "".get_string("noteongradinggrade", "exercise", $course->teacher)."
\n";
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_list_unassessed_student_submissions($exercise, $user) {
// list the student submissions not assessed by the teacher
global $CFG;
$timenow = time();
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
$table->head = array (get_string("title", "exercise"), get_string("submittedby", "exercise"),
get_string("submitted", "exercise"), get_string("action", "exercise"),
get_string("comment", "exercise"));
$table->align = array ("left", "left", "left", "left", "left");
$table->size = array ("*", "*", "*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
// get all the submissions, oldest first, youngest last
// exercise_get_student_submissions is group aware
$groupid = get_current_group($course->id);
if ($groupid) {
if (!$group = get_record("groups", "id", $groupid)) {
error("List unassessed student submissions: group not found");
}
print_heading(get_string("studentsubmissionsforassessment", "exercise", $group->name));
}
if ($submissions = exercise_get_student_submissions($exercise, "time", $groupid)) {
foreach ($submissions as $submission) {
// only consider "cold" submissions
if ($submission->timecreated < $timenow - $CFG->maxeditingtime) {
$comment = "";
// see if student has already submitted
$submissionowner = get_record("user", "id", $submission->userid);
if (exercise_count_user_submissions($exercise, $submissionowner) == 1) {
// it's the student's first submission
// see if there are no cold assessments for this submission
if (!exercise_count_assessments($submission)) {
// now see if the teacher has already assessed this submission
$warm = false;
if ($assessments = get_records("exercise_assessments", "submissionid", $submission->id)) {
foreach ($assessments as $assessment) {
if (isteacher($course->id, $assessment->userid)) {
if ($assessment->timecreated > $timenow -$CFG->maxeditingtime) {
$warm = true;
}
break; // no need to look further
}
}
}
// get their assessment
if ($assessments = exercise_get_user_assessments($exercise, $submissionowner)) {
foreach ($assessments as $assessment) {
$studentassessment = $assessment;
break; // there should only be one!
}
$timegap = get_string("ago", "exercise", format_time($submission->timecreated -
$timenow));
if ($submission->late) {
$timegap = "".$timegap."";
}
if ($warm) {
// last chance salon
$action = "id&aid=$studentassessment->id&sid=$submission->id\">".
get_string("edit", "exercise")."";
$table->data[] = array(exercise_print_submission_title($exercise, $submission),
fullname($submissionowner),
$timegap, $action, $comment);
} else {
$action = "id&aid=$studentassessment->id&sid=$submission->id\">".
get_string("assess", "exercise")."";
$table->data[] = array(exercise_print_submission_title($exercise, $submission),
fullname($submissionowner),
$timegap, $action, $comment);
}
} else {
// there's no student assessment, odd!!
}
}
}
// this is student's second... submission
else {
$teacherassessed = false;
$warm = false;
if ($assessments = get_records("exercise_assessments", "submissionid", $submission->id)) {
foreach ($assessments as $assessment) {
if (isteacher($course->id, $assessment->userid)) {
$teacherassessed = true;
if (!$teacher = get_record("user", "id", $assessment->userid)) {
error("List unassessed student submissions: teacher record not found");
}
$comment = get_string("resubmissionfor", "exercise",
fullname($teacher));
if ($assessment->timecreated > $timenow - $CFG->maxeditingtime) {
$warm = true;
}
break; // no need to look further
}
}
}
if ($teacherassessed and $warm) {
// last chance salon
$action = "id&sid=$submission->id\">".
get_string("edit", "exercise")."";
$timegap = get_string("ago", "exercise", format_time($submission->timecreated -
$timenow));
if ($submission->late) {
$timegap = "".$timegap."";
}
$table->data[] = array(exercise_print_submission_title($exercise, $submission),
fullname($submissionowner),
$timegap, $action, $comment);
}
if (!$teacherassessed) {
// no teacher's assessment
// find who did the previous assessment
if (!$submissions = exercise_get_user_submissions($exercise, $submissionowner)) {
error("List unassessed student submissions: submission records not found");
}
// get the oldest submission, exercise_get_user_submissions returns that first
foreach ($submissions as $tempsubmission) {
$prevsubmission = $tempsubmission;
break;
}
// get the teacher's assessment of the student's previous submission
if ($assessments = get_records("exercise_assessments", "submissionid",
$prevsubmission->id)) {
foreach ($assessments as $assessment) {
if (isteacher($course->id, $assessment->userid)) {
if (!$teacher = get_record("user", "id", $assessment->userid)) {
error("List unassessed student submissions: teacher record not found");
}
$comment = get_string("resubmissionfor", "exercise",
fullname($teacher));
break; // no need to look further
}
}
}
$action = "id&sid=$submission->id\">".
get_string("assess", "exercise")."";
$timegap = get_string("ago", "exercise", format_time($submission->timecreated -
$timenow));
if ($submission->late) {
$timegap = "".$timegap."";
}
$table->data[] = array(exercise_print_submission_title($exercise, $submission),
fullname($submissionowner),
$timegap, $action, $comment);
}
}
}
}
if (isset($table->data)) {
print_table($table);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_list_unassessed_teacher_submissions($exercise, $user) {
// list the teacher submissions not assessed by this user
global $CFG;
$table->head = array (get_string("title", "exercise"), get_string("action", "exercise"), get_string("comment", "exercise"));
$table->align = array ("left", "left", "left");
$table->size = array ("*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
if ($submissions = exercise_get_teacher_submissions($exercise)) {
foreach ($submissions as $submission) {
$comment = "";
// see if user already graded this assessment
if ($assessment = get_record_select("exercise_assessments", "submissionid = $submission->id
AND userid = $user->id")) {
$timenow = time();
if (($timenow - $assessment->timecreated < $CFG->maxeditingtime)) {
// last chance salon
$action = "id&sid=$submission->id\">".
get_string("edit", "exercise")."";
$table->data[] = array(exercise_print_submission_title($exercise, $submission), $action, $comment);
}
}
else { // no assessment
$action = "id&sid=$submission->id\">".
get_string("assess", "exercise")."";
$table->data[] = array(exercise_print_submission_title($exercise, $submission), $action, $comment);
}
}
if (isset($table->data)) {
print_table($table);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_list_ungraded_assessments($exercise, $stype) {
global $CFG;
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
// lists all the assessments of student submissions for grading by teacher
$table->head = array (get_string("title", "exercise"), get_string("submittedby", "exercise"),
get_string("assessor", "exercise"), get_string("timeassessed", "exercise"), get_string("action", "exercise"));
$table->align = array ("left", "left", "left", "left");
$table->size = array ("*", "*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
$timenow = time();
switch ($stype) {
case "student" :
$assessments = exercise_get_ungraded_assessments_student($exercise);
break;
case "teacher" :
$assessments = exercise_get_ungraded_assessments_teacher($exercise);
break;
}
if ($assessments) {
foreach ($assessments as $assessment) {
if (!isteacher($exercise->course, $assessment->userid)) { // don't let teacher grade their own assessments
if (($timenow - $assessment->timegraded) < $CFG->maxeditingtime) {
$action = "id&stype=$stype&aid=$assessment->id\">".
get_string("edit", "exercise")."";
}
else {
$action = "id&stype=$stype&aid=$assessment->id\">".
get_string("grade")."";
}
$submission = get_record("exercise_submissions", "id", $assessment->submissionid);
$submissionowner = get_record("user", "id", $submission->userid);
$assessor = get_record("user", "id", $assessment->userid);
$table->data[] = array(exercise_print_submission_title($exercise, $submission),
fullname($submissionowner),
fullname($assessor), userdate($assessment->timecreated), $action);
}
}
if (isset($table->data)) {
print_table($table);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_list_user_submissions($exercise, $user) {
global $CFG;
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
$timenow = time();
$table->head = array (get_string("title", "exercise"), get_string("action", "exercise"),
get_string("submitted", "exercise"), get_string("assessment", "exercise"));
$table->align = array ("left", "left", "left", "left");
$table->size = array ("*", "*", "*", "*");
$table->cellpadding = 2;
$table->cellspacing = 0;
if ($submissions = exercise_get_user_submissions($exercise, $user)) {
foreach ($submissions as $submission) {
$action = '';
$comment = '';
// allow user to delete submission if it's warm
if ($submission->timecreated > $timenow - $CFG->maxeditingtime) {
$action = "id&sid=$submission->id\">".
get_string("delete", "exercise")."";
}
// if this is a teacher's submission (an exercise description) ignore any assessments
if (!$submission->isexercise) {
// get the teacher assessments (could be more than one, if unlikely, when multiple teachers)
if ($assessments = get_records_select("exercise_assessments", "exerciseid = $exercise->id AND
submissionid = $submission->id")) {
foreach ($assessments as $assessment) {
// make sure it's real
if ($assessment->timecreated < $timenow - $CFG->maxeditingtime) { // it's cold
if ($action) {
$action .= " | ";
}
$action .= "id&aid=$assessment->id\">".
get_string("viewteacherassessment", "exercise", $course->teacher)."";
if ($comment) {
$comment .= " | ";
}
$comment .= get_string("teacherassessment", "exercise", $course->teacher).": ".
number_format($assessment->grade * $exercise->grade / 100.0, 1).
" (".get_string("maximumgrade")." ".number_format($exercise->grade, 0).")";
}
}
}
}
if (!$comment and isstudent($course->id, $user->id)) {
$comment = get_string("awaitingassessmentbythe", "exercise", $course->teacher);
}
$submissiondate = userdate($submission->timecreated);
if ($submission->late) {
$submissiondate = "".$submissiondate."";
}
$table->data[] = array(exercise_print_submission_title($exercise, $submission), $action,
$submissiondate, $comment);
}
print_table($table);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_assessment_form($exercise, $assessment = false, $allowchanges = false, $returnto = '') {
// prints several variants of the assessment form
global $CFG, $THEME, $USER, $EXERCISE_SCALES, $EXERCISE_EWEIGHTS;
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
$timenow = time();
if ($assessment) {
if (!$submission = get_record("exercise_submissions", "id", $assessment->submissionid)) {
error ("exercise_print_assessment_form: Submission record not found");
}
// test if this assessment is from a teacher or student.
// Teacher's assessments are more complicated as we need to go back a couple of steps
// to find the exercise. Student's assessments are directly associated with an exercise.
if (isteacher($course->id, $assessment->userid)) {
// A teacher's assessment, requires getting the student's assessment(s)
// and finding which of those assessments which comes from a teacher submission,
// that is the exercise
$exercisefound = false;
if (!$submissionowner = get_record("user", "id", $submission->userid)) {
error ("exercise_print_assessment_form: User record not found");
}
if ($initialassessments = exercise_get_user_assessments($exercise, $submissionowner)) {
// should only be one but we'll loop anyway
foreach($initialassessments as $initialassessment) {
if (!$teachersubmission = get_record("exercise_submissions", "id", $initialassessment->submissionid)) {
error ("exercise_print_assessment_form: Teacher Submission record not found");
}
if ($teachersubmission->isexercise) {
$exercisefound = true;
break;
}
}
}
if ($exercisefound) {
print_heading(get_string("theexerciseandthesubmissionby", "exercise",
fullname($submissionowner)));
echo "
| cellcontent\">\n";
echo exercise_print_submission_title($exercise, $teachersubmission);
echo " |
\n";
}
}
else {
// it's a student assessment, print instructions if it's their own assessment
if ($assessment->userid == $USER->id) {
print_heading_with_help(get_string("pleaseusethisform", "exercise"), "grading", "exercise");
}
}
echo "
| cellcontent\">\n";
echo exercise_print_submission_title($exercise, $submission);
echo " |
\n";
// only show the grade if grading strategy > 0 and the grade is positive
if ($exercise->gradingstrategy and $assessment->grade >= 0) {
echo "".get_string("thegradeis", "exercise").": ".
number_format($assessment->grade * $exercise->grade / 100.0, 2)." (".
get_string("maximumgrade")." ".number_format($exercise->grade, 0).")
\n";
}
}
// now print the grading form with the teacher's comments if any
// FORM is needed for Mozilla browsers, else radio bttons are not checked
?>
\n";
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_assessments_by_user_for_admin($exercise, $user) {
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
if ($assessments =exercise_get_user_assessments($exercise, $user)) {
foreach ($assessments as $assessment) {
echo "".get_string("assessmentby", "exercise", fullname($user))."\n";
exercise_print_assessment_form($exercise, $assessment);
echo "id&aid=$assessment->id\">".
get_string("amend", "exercise")." ".get_string("gradeforstudentsassessment","exercise",
$course->student)."\n";
echo " | id&aid=$assessment->id\">".
get_string("delete", "exercise")."
\n";
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_assessments_for_admin($exercise, $submission) {
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
if ($assessments = exercise_get_assessments($submission)) {
foreach ($assessments as $assessment) {
if (!$user = get_record("user", "id", $assessment->userid)) {
error (" exercise_print_assessments_for_admin: unable to get user record");
}
echo "".get_string("assessmentby", "exercise", fullname($user))."\n";
exercise_print_assessment_form($exercise, $assessment);
echo "id&aid=$assessment->id\">".
get_string("delete", "exercise")."
\n";
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_assignment_info($exercise) {
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
// print standard assignment heading
$strdifference = format_time($exercise->deadline - time());
if (($exercise->deadline - time()) < 0) {
$strdifference = "$strdifference";
}
$strduedate = userdate($exercise->deadline)." ($strdifference)";
print_simple_box_start("center");
print_heading($exercise->name, "center");
print_simple_box_start("center");
echo "".get_string("duedate", "exercise").": $strduedate
";
$maxgrade = $exercise->grade + $exercise->gradinggrade;
echo "".get_string("maximumgrade").": $maxgrade
";
echo "".get_string("handlingofmultiplesubmissions", "exercise").":";
if ($exercise->usemaximum) {
echo get_string("usemaximum", "exercise")."
\n";
}
else {
echo get_string("usemean", "exercise")."
\n";
}
echo "".get_string("detailsofassessment", "exercise").":
id&action=displaygradingform\">".
get_string("specimenassessmentform", "exercise")."
";
print_simple_box_end();
print_simple_box_end();
echo "
";
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_difference($time) {
if ($time < 0) {
$timetext = get_string("late", "assignment", format_time($time));
return " ($timetext)";
} else {
$timetext = get_string("early", "assignment", format_time($time));
return " ($timetext)";
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_feedback($course, $submission) {
global $CFG, $THEME, $RATING;
if (! $teacher = get_record("user", "id", $submission->teacher)) {
error("Weird exercise error");
}
echo "\n";
echo "\n";
echo "\n";
echo "\n| body\" width=\"35\" valign=\"top\">";
print_user_picture($teacher->id, $course->id, $teacher->picture);
echo " | ";
echo "cellheading\">".fullname($teacher);
echo " ".userdate($submission->timemarked)."";
echo " | ";
echo "\n| cellcontent\">";
echo " ";
if ($submission->grade) {
echo get_string("grade").": $submission->grade";
} else {
echo get_string("nograde");
}
echo " ";
echo text_to_html($submission->assessorcomment);
echo " | ";
echo " |
";
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_league_table($exercise) {
// print an order table of (student) submissions in grade order, only print the student's best submission when
// there are multiple submissions
if (! $course = get_record("course", "id", $exercise->course)) {
error("Print league table: Course is misconfigured");
}
$groupid = get_current_group($course->id);
$nentries = $exercise->showleaguetable;
if ($nentries == 99) {
$nentries = 999999; // a large number
}
if ($exercise->anonymous and isstudent($course->id)) {
$table->head = array (get_string("title", "exercise"), get_string("grade"));
$table->align = array ("left", "center");
$table->size = array ("*", "*");
} else { // show names
$table->head = array (get_string("title", "exercise"), get_string("name"), get_string("grade"));
$table->align = array ("left", "left", "center");
$table->size = array ("*", "*", "*");
}
$table->cellpadding = 2;
$table->cellspacing = 0;
if ($submissions = exercise_get_student_submissions($exercise, "grade", $groupid)) {
$n = 1;
foreach ($submissions as $submission) {
if (empty($done[$submission->userid])) {
if ($submission->late) {
continue;
}
if (!$user = get_record("user", "id", $submission->userid)) {
error("Print league table: user not found");
}
if ($exercise->anonymous and isstudent($course->id)) {
$table->data[] = array(exercise_print_submission_title($exercise, $submission),
number_format($submission->grade * $exercise->grade / 100.0, 1));
} else {
$table->data[] = array(exercise_print_submission_title($exercise, $submission),
fullname($user),
number_format($submission->grade * $exercise->grade / 100.0, 1));
}
$n++;
if ($n > $nentries) {
break;
}
$done[$submission->userid] = 'ok';
}
}
print_heading(get_string("leaguetable", "exercise"));
print_table($table);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_submission_assessments($exercise, $submission) {
// Returns a list of grades for this submission
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
$str = '';
if ($assessments = exercise_get_assessments($submission)) {
foreach ($assessments as $assessment) {
if (isteacher($exercise->course, $assessment->userid)) {
$str .= "[".number_format($assessment->grade * $exercise->grade / 100.0, 0)."] ";
}
else { // assessment by student - shouldn't happen!
$str .= "{".number_format($assessment->grade * $exercise->grade / 100.0, 0)."} ";
}
}
}
if (!$str) {
$str = " "; // be kind to Mozilla browsers!
}
return $str;
}
//////////////////////////////////////////////////////////////////////////////////////
function exercise_print_tabbed_heading($tabs) {
// Prints a tabbed heading where one of the tabs highlighted.
// $tabs is an object with several properties.
// $tabs->names is an array of tab names
// $tabs->urls is an array of links
// $tabs->align is an array of column alignments (defaults to "center")
// $tabs->size is an array of column sizes
// $tabs->wrap is an array of "nowrap"s or nothing
// $tabs->highlight is an index (zero based) of "active" heading .
// $tabs->width is an percentage of the page (defualts to 80%)
// $tabs->cellpadding padding on each cell (defaults to 5)
global $CFG, $THEME;
if (isset($tabs->names)) {
foreach ($tabs->names as $key => $name) {
if (!empty($tabs->urls[$key])) {
$url =$tabs->urls[$key];
if ($tabs->highlight == $key) {
$tabcontents[$key] = "$name";
} else {
$tabcontents[$key] = "$name";
}
} else {
$tabcontents[$key] = "$name";
}
}
}
if (empty($tabs->width)) {
$tabs->width = "80%";
}
if (empty($tabs->cellpadding)) {
$tabs->cellpadding = "5";
}
// print_simple_box_start("center", "$table->width", "#ffffff", 0);
echo "cellpadding\" cellspacing=\"0\" class=\"generaltable\">\n";
if (!empty($tabs->names)) {
echo "";
echo "".
"![](\"$CFG-) wwwroot/pix/spacer.gif\" alt=\"\" /> | \n";
foreach ($tabcontents as $key => $tab) {
if (isset($align[$key])) {
$alignment = "align=\"$align[$key]\"";
} else {
$alignment = "align=\"center\"";
}
if (isset($size[$key])) {
$width = "width=\"$size[$key]\"";
} else {
$width = "";
}
if (isset($wrap[$key])) {
$wrapping = "no wrap";
} else {
$wrapping = "";
}
if ($key == $tabs->highlight) {
echo "cellheading2\">$tab | \n";
} else {
echo "cellheading\">$tab | \n";
}
echo "".
"wwwroot/pix/spacer.gif\" alt=\"\" /> | \n";
}
echo "
\n";
} else {
echo "| No names specified |
\n";
}
// bottom stripe
$ncells = count($tabs->names)*2 +1;
$height = 2;
echo "| cellheading2\">".
"wwwroot/pix/spacer.gif\" alt=\"\" /> |
\n";
echo "
\n";
// print_simple_box_end();
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_teacher_assessment_form($exercise, $assessment, $submission, $returnto = '') {
// prints an assessment form based on the student's assessment
// if the teacher is re-assessing a submission they would use exercise_print_assessment_form()
// (for teachers only)
global $CFG, $THEME, $USER, $EXERCISE_SCALES, $EXERCISE_EWEIGHTS;
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
$timenow = time();
if(!$submissionowner = get_record("user", "id", $submission->userid)) {
error("Print teacher assessment form: User record not found");
}
echo "
| cellcontent\">\n";
if (!$teachersubmission = get_record("exercise_submissions", "id", $assessment->submissionid)) {
error ("Print teacher assessment form: Submission record not found");
}
echo exercise_print_submission_title($exercise, $teachersubmission);
echo " |
\n";
echo "
| cellcontent\">\n";
echo exercise_print_submission_title($exercise, $submission);
echo " |
\n";
?>
\n";
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_teacher_table($course) {
// print how many assessments each teacher has done in each exercise
if (! $exercises = get_all_instances_in_course("exercise", $course)) {
notice("There are no exercises", "../../course/view.php?id=$course->id");
die;
}
$timenow = time();
$table->head[] = '';
$table->align[] = 'left';
$table->size[] = '*';
$table->head[] = get_string("total");
$table->align[] = "center";
$table->size[] = "*";
foreach ($exercises as $exercise) {
$table->head[] = $exercise->name;
$table->align[] = "center";
$table->size[] = "*";
}
$table->cellpadding = 2;
$table->cellspacing = 0;
if (!$teachers = get_course_teachers($course->id, "u.firstname, u.lastname")) {
error("No teachers on this course!");
}
for ($j = 0; $j < count($exercises); $j++) {
$grand[$j] = 0;
}
$grandtotal = 0;
foreach ($teachers as $teacher) {
unset($n);
$total = 0;
$j = 0;
foreach ($exercises as $exercise) {
$i = exercise_count_assessments_by_teacher($exercise, $teacher);
$n[] = $i;
$total += $i;
$grand[$j] += $i;
$j++;
}
$grandtotal += $total;
$table->data[] = array_merge(array(fullname($teacher)), array($total), $n);
}
$table->data[] = array_merge(array(get_string("total")), array($grandtotal), $grand);
print_heading(get_string("teacherassessmenttable", "exercise", $course->teacher));
print_table($table);
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_time_to_deadline($time) {
if ($time < 0) {
$timetext = get_string("afterdeadline", "exercise", format_time($time));
return " ($timetext)";
} else {
$timetext = get_string("beforedeadline", "exercise", format_time($time));
return " ($timetext)";
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_upload_form($exercise) {
global $CFG;
if (! $course = get_record("course", "id", $exercise->course)) {
error("Course is misconfigured");
}
if (! $cm = get_coursemodule_from_instance("exercise", $exercise->id, $course->id)) {
error("Course Module ID was incorrect");
}
echo "";
echo "";
echo "
";
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_print_user_assessments($exercise, $user) {
// Returns the number of assessments and a hyperlinked list of grading grades for the assessments made by this user
if ($assessments = exercise_get_user_assessments($exercise, $user)) {
$n = count($assessments);
$str = "$n (";
foreach ($assessments as $assessment) {
if ($assessment->timegraded) {
$gradingscaled = round($assessment->gradinggrade * $exercise->gradinggrade / 100.0);
$str .= "id&aid=$assessment->id\">";
$str .= "$gradingscaled ";
}
else {
$str .= "id&aid=$assessment->id\">";
$str .= "- ";
}
}
$str .= ")";
}
else {
$str ="0";
}
return $str;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_test_for_resubmission($exercise, $user) {
// see if any of the user's submissions have the resubmit flag set
$result = false;
if ($submissions = exercise_get_user_submissions($exercise, $user)) {
foreach ($submissions as $submission) {
if ($submission->resubmit) {
$result =true;
break;
}
}
}
return $result;
}
///////////////////////////////////////////////////////////////////////////////////////////////
function exercise_test_user_assessments($exercise, $user) {
// see if user has assessed one of teacher's exercises/submissions...
global $CFG;
$result = false;
$timenow =time();
if ($submissions = exercise_get_teacher_submissions($exercise)) {
foreach ($submissions as $submission) {
if ($assessment = exercise_get_submission_assessment($submission, $user)) {
// ...the date stamp on the assessment should be in the past
if ($assessment->timecreated < $timenow) {
$result = true;
break;
}
}
}
}
return $result;
}
?>