"; } else { // don't break anonymous rule echo "
$date - A $course->student
";
}
echo "\"wwwroot/mod/workshop/".str_replace('&', '&', $log->url)."\">";
echo "$log->name";
echo "\"
$date - ".fullname($log)." $date - A $course->student $date - A $course->student $date - $course->teacher $date - ".fullname($log)." ".get_string("numberofsubmissions", "workshop", count($num))."
";
}
else { // don't break anonymous rule
echo "
";
}
echo "\"wwwroot/mod/workshop/".str_replace('&', '&', $log->url)."\">";
echo "$log->name";
echo "\"
";
echo "\"wwwroot/mod/workshop/".str_replace('&', '&', $log->url)."\">";
echo "$log->name";
echo "\"
";
echo "\"wwwroot/mod/workshop/".str_replace('&', '&', $log->url)."\">";
echo "$log->name";
echo "\"
";
echo "\"wwwroot/mod/workshop/".str_replace('&', '&', $log->url)."\">";
echo "$log->name";
echo "\"';
if ($activity->content->parent) {
$openformat = "";
$closeformat = "";
} else {
$openformat = "";
$closeformat = "";
}
echo "
";
return;
}
//////////////////////////////////////////////////////////////////////////////////////
// Non-standard workshop functions
///////////////////////////////////////////////////////////////////////////////////////////////
function workshop_compare_assessments($workshop, $assessment1, $assessment2) {
global $WORKSHOP_ASSESSMENT_COMPS, $WORKSHOP_EWEIGHTS;
// first get the assignment elements for maxscores...
$elementsraw = get_records("workshop_elements", "workshopid", $workshop->id, "elementno ASC");
foreach ($elementsraw as $element) {
$maxscore[] = $element->maxscore; // to renumber index 0,1,2...
$weight[] = $WORKSHOP_EWEIGHTS[$element->weight]; // get real value and renumber index 0,1,2...
}
for ($i = 0; $i < 2; $i++) {
if ($i) {
$rawgrades = get_records("workshop_grades", "assessmentid", $assessment1->id, "elementno ASC");
} else {
$rawgrades = get_records("workshop_grades", "assessmentid", $assessment2->id, "elementno ASC");
}
foreach ($rawgrades as $grade) {
$grades[$i][] = $grade->grade;
}
}
$sumdiffs = 0;
$sumweights = 0;
switch ($workshop->gradingstrategy) {
case 1 : // accumulative grading and...
case 4 : // ...rubic grading
for ($i=0; $i < $workshop->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 < $workshop->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)$WORKSHOP_ASSESSMENT_COMPS[$workshop->assessmentcomps];
$factor = $COMP->value;
$gradinggrade = (($factor - ($sumdiffs / $sumweights)) / $factor) * 100;
if ($gradinggrade < 0) {
$gradinggrade = 0;
}
return $gradinggrade;
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_count_assessments($submission) {
// Return the (real) assessments for this submission,
$timenow = time();
return count_records_select("workshop_assessments",
"submissionid = $submission->id AND timecreated < $timenow");
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_count_ungraded_assessments($workshop) {
// function returns the number of ungraded assessments by students
global $CFG;
$timenow = time();
$n = 0;
// get all the cold assessments that have not been graded
if ($assessments = get_records_select("workshop_assessments", "workshopid = $workshop->id AND
(timecreated + $CFG->maxeditingtime) < $timenow AND timegraded = 0")) {
foreach ($assessments as $assessment) {
if (isstudent($workshop->course, $assessment->userid)) {
$n++;
}
}
}
return $n;
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_file_area($workshop, $submission) {
return make_upload_directory( workshop_file_area_name($workshop, $submission) );
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_file_area_name($workshop, $submission) {
// Creates a directory file name, suitable for make_upload_directory()
global $CFG;
return "$workshop->course/$CFG->moddata/workshop/$submission->id";
}
///////////////////////////////////////////////////////////////////////////////////////////////
function workshop_get_agree_logs($course, $timestart) {
// get the "agree" entries for this user (the assessment owner and add the first and last names
// the last two probably wont be used...
global $CFG, $USER;
if (empty($USER->id)) {
return false;
}
$timethen = time() - $CFG->maxeditingtime;
return get_records_sql("SELECT l.time, l.url, u.firstname, u.lastname, a.workshopid, a.userid, e.name
FROM {$CFG->prefix}log l,
{$CFG->prefix}workshop e,
{$CFG->prefix}workshop_submissions s,
{$CFG->prefix}workshop_assessments a,
{$CFG->prefix}user u
WHERE l.time > $timestart AND l.time < $timethen
AND l.course = $course->id AND l.module = 'workshop' AND l.action = 'agree'
AND a.id = l.info AND s.id = a.submissionid AND a.userid = $USER->id
AND u.id = s.userid AND e.id = a.workshopid");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function workshop_get_assess_logs($course, $timestart) {
// get the "assess" entries for this user and add the first and last names...
global $CFG, $USER;
if (empty($USER->id)) {
return false;
}
$timethen = time() - $CFG->maxeditingtime;
return get_records_sql("SELECT l.time, l.url, u.firstname, u.lastname, a.workshopid, a.userid, e.name
FROM {$CFG->prefix}log l,
{$CFG->prefix}workshop e,
{$CFG->prefix}workshop_submissions s,
{$CFG->prefix}workshop_assessments a,
{$CFG->prefix}user u
WHERE l.time > $timestart AND l.time < $timethen
AND l.course = $course->id AND l.module = 'workshop' AND l.action = 'assess'
AND a.id = l.info AND s.id = a.submissionid AND s.userid = $USER->id
AND u.id = a.userid AND e.id = a.workshopid");
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_get_assessments($submission, $all = '', $order = '') {
// Return assessments for this submission ordered oldest first, newest last
// new assessments made within the editing time are NOT returned unless the
// second argument is set to ALL
global $CFG;
if (!$order) {
$order = "timecreated DESC";
}
if ($all != 'ALL') {
$timenow = time();
return get_records_select("workshop_assessments", "(submissionid = $submission->id) AND
(timecreated < $timenow - $CFG->maxeditingtime)", $order);
} else {
return get_records_select("workshop_assessments", "submissionid = $submission->id",
$order);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
function workshop_get_comment_logs($course, $timestart) {
// get the "comment" entries for this user and add the first and last names (which may not be used)...
global $CFG, $USER;
if (empty($USER->id)) {
return false;
}
$timethen = time() - $CFG->maxeditingtime;
return get_records_sql("SELECT l.time, l.url, u.firstname, u.lastname, a.workshopid, e.name
FROM {$CFG->prefix}log l,
{$CFG->prefix}workshop e,
{$CFG->prefix}workshop_submissions s,
{$CFG->prefix}workshop_assessments a,
{$CFG->prefix}workshop_comments c,
{$CFG->prefix}user u
WHERE l.time > $timestart AND l.time < $timethen
AND l.course = $course->id AND l.module = 'workshop' AND l.action = 'comment'
AND c.id = l.info AND c.userid != $USER->id AND a.id = c.assessmentid
AND s.id = a.submissionid AND (s.userid = $USER->id OR a.userid = $USER->id)
AND u.id = a.userid AND e.id = a.workshopid");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function workshop_get_grade_logs($course, $timestart) {
// get the "grade" entries for this user and add the first and last names (of submission owner,
// better to get name of teacher...
// ...but not available in assessment record...)
global $CFG, $USER;
if (empty($USER->id)) {
return false;
}
$timethen = time() - $CFG->maxeditingtime;
return get_records_sql("SELECT l.time, l.url, u.firstname, u.lastname, a.workshopid, e.name
FROM {$CFG->prefix}log l,
{$CFG->prefix}workshop e,
{$CFG->prefix}workshop_submissions s,
{$CFG->prefix}workshop_assessments a,
{$CFG->prefix}user u
WHERE l.time > $timestart AND l.time < $timethen
AND l.course = $course->id AND l.module = 'workshop' AND l.action = 'grade'
AND a.id = l.info AND s.id = a.submissionid AND a.userid = $USER->id
AND u.id = s.userid AND e.id = a.workshopid");
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_get_student_submission($workshop, $user) {
// Return a submission for a particular user
global $CFG;
$submission = get_record("workshop_submissions", "workshopid", $workshop->id, "userid", $user->id);
if (!empty($submission->timecreated)) {
return $submission;
}
return NULL;
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_get_student_submissions($workshop, $order = "title") {
// Return all ENROLLED student submissions
global $CFG;
if ($order == "title") {
$order = "s.title";
}
if ($order == "name") {
$order = "a.lastname, a.firstname";
}
if ($order == "time") {
$order = "s.timecreated ASC";
}
// make sure it works on the site course
$select = "u.course = '$workshop->course' AND";
$site = get_site();
if ($workshop->course == $site->id) {
$select = '';
}
return get_records_sql("SELECT s.* FROM {$CFG->prefix}workshop_submissions s,
{$CFG->prefix}user_students u, {$CFG->prefix}user a
WHERE $select s.userid = u.userid
AND a.id = u.userid
AND s.workshopid = $workshop->id
AND s.timecreated > 0
ORDER BY $order");
}
///////////////////////////////////////////////////////////////////////////////////////////////
function workshop_get_submit_logs($course, $timestart) {
// get the "submit" entries and add the first and last names...
global $CFG, $USER;
$timethen = time() - $CFG->maxeditingtime;
return get_records_sql("SELECT l.time, l.url, u.firstname, u.lastname, l.info as workshopid, e.name
FROM {$CFG->prefix}log l,
{$CFG->prefix}workshop e,
{$CFG->prefix}user u
WHERE l.time > $timestart AND l.time < $timethen
AND l.course = $course->id AND l.module = 'workshop'
AND l.action = 'submit'
AND e.id = l.info
AND u.id = l.userid");
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_get_unmailed_assessments($cutofftime) {
/// Return list of assessments that have not been mailed out
global $CFG;
return get_records_sql("SELECT a.*, g.course, g.name
FROM {$CFG->prefix}workshop_assessments a, {$CFG->prefix}workshop g
WHERE a.mailed = 0
AND a.timecreated < $cutofftime
AND g.id = a.workshopid");
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_get_unmailed_comments($cutofftime) {
/// Return list of comments that have not been mailed out
global $CFG;
return get_records_sql("SELECT c.*, g.course, g.name
FROM {$CFG->prefix}workshop_comments c, {$CFG->prefix}workshop g
WHERE c.mailed = 0
AND c.timecreated < $cutofftime
AND g.id = c.workshopid");
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_get_unmailed_graded_assessments($cutofftime) {
/// Return list of graded assessments that have not been mailed out
global $CFG;
return get_records_sql("SELECT a.*, g.course, g.name
FROM {$CFG->prefix}workshop_assessments a, {$CFG->prefix}workshop g
WHERE a.mailed = 0
AND a.timegraded < $cutofftime
AND a.timegraded > 0
AND g.id = a.workshopid");
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_get_unmailed_resubmissions($cutofftime) {
/// Return list of assessments of resubmissions that have not been mailed out
global $CFG;
return get_records_sql("SELECT a.*, w.course, w.name
FROM {$CFG->prefix}workshop_assessments a, {$CFG->prefix}workshop w
WHERE a.mailed = 0
AND a.resubmission = 1
AND w.id = a.workshopid");
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_get_user_assessments($workshop, $user) {
// Return all the user's assessments, newest first, oldest last (hot, warm and cold ones)
return get_records_select("workshop_assessments", "workshopid = $workshop->id AND userid = $user->id",
"timecreated DESC");
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_get_user_submissions($workshop, $user) {
// return real submissions of user newest first, oldest last. Ignores the dummy submissions
// which get created to hold the final grades for users for make no submissions)
return get_records_select("workshop_submissions", "workshopid = $workshop->id AND
userid = $user->id AND timecreated > 0", "timecreated DESC" );
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_grade_assessments($workshop) {
global $WORKSHOP_EWEIGHTS;
// timeout after 10 minutes
@set_time_limit(600);
$timenow = time();
// set minumim value for the variance (of the elements)
$minvar = 0.05;
// check when the standard deviations were calculated
$oldtotalassessments = get_field("workshop_elements", "totalassessments", "workshopid", $workshop->id,
"elementno", 0);
$totalassessments = count_records("workshop_assessments", "workshopid", $workshop->id);
// calculate the std. devs every 10 assessments for low numbers of assessments, thereafter every 100 new assessments
if ((($totalassessments < 100) and (($totalassessments - $oldtotalassessments) > 10)) or
(($totalassessments - $oldtotalassessments) > 100)) {
// calculate the means for each submission using just the "good" assessments
if ($submissions = get_records("workshop_submissions", "workshopid", $workshop->id)) {
foreach ($submissions as $submission) {
$nassessments[$submission->id] = 0;
if ($assessments = workshop_get_assessments($submission)) {
foreach ($assessments as $assessment) {
// test if assessment is "good", a teacher assessment always "good", but may be weighted out
if (isteacher($workshop->course, $assessment->userid)) {
if (!$workshop->teacherweight) {
// drop teacher's assessment as weight is zero
continue;
}
} elseif ((!$assessment->gradinggrade and $assessment->timegraded) or
($workshop->agreeassessments and !$assessment->timeagreed)) {
// it's a duff assessment, or it's not been agreed
continue;
}
if (isset($num[$submission->id])) {
if (isteacher($workshop->course, $assessment->userid)) {
$num[$submission->id] += $workshop->teacherweight; // weight teacher's assessment
} else {
$num[$submission->id]++; // number of assessments
}
$nassessments[$submission->id]++;
} else {
if (isteacher($workshop->course, $assessment->userid)) {
$num[$submission->id] = $workshop->teacherweight;
} else {
$num[$submission->id] = 1;
}
$nassessments[$submission->id] = 1;
}
for ($i = 0; $i < $workshop->nelements; $i++) {
$grade = get_field("workshop_grades", "grade",
"assessmentid", $assessment->id, "elementno", $i);
if (isset($sum[$submission->id][$i])) {
if (isteacher($workshop->course, $assessment->userid)) {
$sum[$submission->id][$i] += $workshop->teacherweight * $grade; // teacher's grade
} else {
$sum[$submission->id][$i] += $grade; // student's grade
}
} else {
if (isteacher($workshop->course, $assessment->userid)) {
$sum[$submission->id][$i] = $workshop->teacherweight * $grade; // teacher's grade
} else {
$sum[$submission->id][$i] = $grade; // students's grade
}
}
}
}
}
}
if (!isset($num)) {
// no assessments yet
return;
}
reset($num);
// calculate the means for each submission
$total = 0;
foreach ($num as $submissionid => $n) {
if ($n) { // stop division by zero
for ($i = 0; $i < $workshop->nelements; $i++) {
$mean[$submissionid][$i] = $sum[$submissionid][$i] / $n;
// echo "Submission: $submissionid; Element: $i; Mean: {$mean[$submissionid][$i]}cellcontent2\" class=\"workshoppostpicture\" width=\"35\" valign=\"top\">";
print_user_picture($activity->user->userid, $course, $activity->user->picture);
echo " $openformat";
if ($detail) {
echo " modpixpath/$activity->type/icon.gif\" ".
"height=\"16\" width=\"16\" alt=\"$activity->name\" /> ";
}
echo "wwwroot/mod/workshop/view.php?"
. "#" . $activity->content->id . "\">".$activity->content->title;
echo "$closeformat";
echo "
";
echo "wwwroot/user/view.php?id=" . $activity->user->userid . "&course=" . "$course\">"
. $activity->user->fullname . "";
echo " - " . userdate($activity->timestamp) . "
\n";
}
$total += $n; // weighted total
}
}
echo "
\n";
echo get_string("numberofassessmentsweighted", "workshop", $total)."
";
if ($sd[$i] <= $minvar) {
print_string("standarddeviationnote", "workshop")."
\n";
}
}
}
}
// this section looks at each submission if the number of assessments made has increased it recalculates the
// grading grades for those assessments
// first get the assignment elements for the weights and the stddevs...
$elementsraw = get_records("workshop_elements", "workshopid", $workshop->id, "elementno ASC");
foreach ($elementsraw as $element) {
$weight[] = $element->weight; // to renumber index 0,1,2...
$sd[] = $element->stddev; // to renumber index 0,1,2...
}
unset($num); // may have been used in calculating stddevs
unset($sum); // ditto
if ($submissions = get_records("workshop_submissions", "workshopid", $workshop->id)) {
foreach ($submissions as $submission) {
// see if the number of assessments has changed
$nassessments = workshop_count_assessments($submission);
if ($submission->nassessments <> $nassessments) {
// ...if there are three or more assessments calculate the variance of each assessment.
// Use the variance to find the "best" assessment. (When there is only one or two assessments they
// are not altered by this routine.)
echo "Processing submission $submission->id ($nassessments asessments)...\n";
if ($nassessments > 2) {
$num = 0; // weighted number of assessments
for ($i = 0; $i < $workshop->nelements; $i++) {
$sum[$i] = 0; // weighted sum of grades
}
if ($assessments = workshop_get_assessments($submission)) {
// first calculate the mean grades for each element
foreach ($assessments as $assessment) {
// test if assessment is "good", a teacher assessment always "good", but may be weighted out
if (isteacher($workshop->course, $assessment->userid)) {
if (!$workshop->teacherweight) {
// drop teacher's assessment as weight is zero
continue;
}
} elseif ((!$assessment->gradinggrade and $assessment->timegraded) or
($workshop->agreeassessments and !$assessment->timeagreed)) {
// it's a duff assessment, or it's not been agreed
continue;
}
if (isteacher($workshop->course, $assessment->userid)) {
$num += $workshop->teacherweight; // weight teacher's assessment
} else {
$num++; // student assessment just add one
}
for ($i = 0; $i < $workshop->nelements; $i++) {
$grade = get_field("workshop_grades", "grade",
"assessmentid", $assessment->id, "elementno", $i);
if (isteacher($workshop->course, $assessment->userid)) {
$sum[$i] += $workshop->teacherweight * $grade; // teacher's grade
} else {
$sum[$i] += $grade; // student's grade
}
}
}
if ($num) { // could all the assessments be duff?
for ($i = 0; $i < $workshop->nelements; $i++) {
$mean[$i] = $sum[$i] / $num;
echo "Submission: $submission->id; Element: $i; Mean: {$mean[$i]}\n";
}
} else {
continue; // move to the next submission
}
// run through the assessments again to see which is the "best" one (the one
// closest to the mean)
$lowest = 10e9;
foreach ($assessments as $assessment) {
if ($workshop->agreeassessments and !$assessment->timeagreed) {
// ignore assessments that have not been agreed
continue;
}
$var = 0;
for ($i = 0; $i < $workshop->nelements; $i++) {
$grade = get_field("workshop_grades", "grade",
"assessmentid", $assessment->id, "elementno", $i);
if ($sd[$i] > $minvar) {
$temp = ($mean[$i] - $grade) *
$WORKSHOP_EWEIGHTS[$weight[$i]] / $sd[$i];
} else {
$temp = 0;
}
$var += $temp * $temp;
}
// find the "best" assessment of this submission
if ($lowest > $var) {
$lowest = $var;
$bestassessmentid = $assessment->id;
}
}
if (!$best = get_record("workshop_assessments", "id", $bestassessmentid)) {
error("Workshop grade assessments: cannot find best assessment");
}
echo "Best assessment is $bestassessmentid;\n";
foreach ($assessments as $assessment) {
if ($assessment->id == $bestassessmentid) {
// it's the best one, set the grading grade to the maximum
set_field("workshop_assessments", "gradinggrade", 100, "id", $assessment->id);
set_field("workshop_assessments", "timegraded", $timenow, "id", $assessment->id);
} else {
// it's one of the pack, compare with the best...
$gradinggrade = workshop_compare_assessments($workshop, $best, $assessment);
// ...and save the grade for the assessment
set_field("workshop_assessments", "gradinggrade", $gradinggrade, "id", $assessment->id);
set_field("workshop_assessments", "timegraded", $timenow, "id", $assessment->id);
}
}
}
} else {
// there are less than 3 assessments for this submission
if ($assessments = workshop_get_assessments($submission)) {
foreach ($assessments as $assessment) {
if (!$assessment->timegraded) {
// set the grading grade to the maximum and say it's been graded
set_field("workshop_assessments", "gradinggrade", 100, "id", $assessment->id);
set_field("workshop_assessments", "timegraded", $timenow, "id", $assessment->id);
}
}
}
}
// set the number of assessments for this submission
set_field("workshop_submissions", "nassessments", $nassessments, "id", $submission->id);
}
}
}
return;
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_gradinggrade($workshop, $student) {
// returns the current (external) grading grade of the based on their (cold) assessments
// (needed as it's called by grade)
$gradinggrade = 0;
if ($assessments = workshop_get_user_assessments($workshop, $student)) {
$n = 0;
foreach ($assessments as $assessment) {
$gradinggrade += $assessment->gradinggrade;
$n++;
}
if ($n < ($workshop->ntassessments + $workshop->nsassessments)) { // the minimum students should do
$n = $workshop->ntassessments + $workshop->nsassessments;
}
$gradinggrade = $gradinggrade / $n;
}
return number_format($gradinggrade * $workshop->gradinggrade / 100, 1);
}
//////////////////////////////////////////////////////////////////////////////////////
function workshop_submission_grade($workshop, $submission) {
// returns the current (external) grade of the submission based on the "good" (cold) assessments
// (needed as it's called by grade)
$grade = 0;
if ($assessments = workshop_get_assessments($submission)) {
$n = 0;
foreach ($assessments as $assessment) {
if ($workshop->agreeassessments and !$assessment->timeagreed) {
// ignore assessments which have not been agreed
continue;
}
if ($assessment->gradinggrade or !$assessment->timegraded) {
// a good assessment (or one that has not been graded yet)
if (isteacher($workshop->course, $assessment->userid)) {
$timenow = time();
if ($timenow > $workshop->releasegrades) {
// teacher's grade is available
$grade += $workshop->teacherweight * $assessment->grade;
$n += $workshop->teacherweight;
}
} else {
$grade += $assessment->grade;
$n++;
}
}
}
if ($n) { // stop division by zero
$grade = $grade / $n;
}
}
return number_format($grade * $workshop->grade / 100, 1);
}
?>