| ';
print_paging_bar($numquestions, $page, $perpage,
"edit.php?perpage=$perpage&");
echo "\n";
if ($quizselected) {
for ($i=1;$i<=10; $i++) {
$randomcount[$i] = $i;
}
echo '';
}
}
function quiz_start_attempt($quizid, $userid, $numattempt) {
$attempt->quiz = $quizid;
$attempt->userid = $userid;
$attempt->attempt = $numattempt;
$attempt->timestart = time();
$attempt->timefinish = 0;
$attempt->timemodified = time();
$attempt->id = insert_record("quiz_attempts", $attempt);
return $attempt;
}
function quiz_get_user_attempt_unfinished($quizid, $userid) {
// Returns an object containing an unfinished attempt (if there is one)
return get_record("quiz_attempts", "quiz", $quizid, "userid", $userid, "timefinish", 0);
}
function quiz_get_user_attempts($quizid, $userid) {
// Returns a list of all attempts by a user
return get_records_select("quiz_attempts", "quiz = '$quizid' AND userid = '$userid' AND timefinish > 0",
"attempt ASC");
}
function quiz_get_user_attempts_string($quiz, $attempts, $bestgrade) {
/// Returns a simple little comma-separated list of all attempts,
/// with each grade linked to the feedback report and with the best grade highlighted
$bestgrade = format_float($bestgrade,$quiz->decimalpoints);
foreach ($attempts as $attempt) {
$attemptgrade = format_float(($attempt->sumgrades / $quiz->sumgrades) * $quiz->grade, $quiz->decimalpoints);
if ($attemptgrade == $bestgrade) {
$userattempts[] = "id&attempt=$attempt->id\">$attemptgrade";
} else {
$userattempts[] = "id&attempt=$attempt->id\">$attemptgrade";
}
}
return implode(",", $userattempts);
}
function quiz_get_best_grade($quiz, $userid) {
/// Get the best current grade for a particular user in a quiz
if (!$grade = get_record('quiz_grades', 'quiz', $quiz->id, 'userid', $userid)) {
return NULL;
}
return (format_float($grade->grade,$quiz->decimalpoints));
}
function quiz_save_best_grade($quiz, $userid) {
/// Calculates the best grade out of all attempts at a quiz for a user,
/// and then saves that grade in the quiz_grades table.
if (!$attempts = quiz_get_user_attempts($quiz->id, $userid)) {
notify('Could not find any user attempts');
return false;
}
$bestgrade = quiz_calculate_best_grade($quiz, $attempts);
$bestgrade = (($bestgrade / $quiz->sumgrades) * $quiz->grade);
if ($grade = get_record('quiz_grades', 'quiz', $quiz->id, 'userid', $userid)) {
$grade->grade = round($bestgrade, $quiz->decimalpoints);
$grade->timemodified = time();
if (!update_record('quiz_grades', $grade)) {
notify('Could not update best grade');
return false;
}
} else {
$grade->quiz = $quiz->id;
$grade->userid = $userid;
$grade->grade = round($bestgrade, $quiz->decimalpoints);
$grade->timemodified = time();
if (!insert_record('quiz_grades', $grade)) {
notify('Could not insert new best grade');
return false;
}
}
return true;
}
function quiz_calculate_best_grade($quiz, $attempts) {
/// Calculate the best grade for a quiz given a number of attempts by a particular user.
switch ($quiz->grademethod) {
case ATTEMPTFIRST:
foreach ($attempts as $attempt) {
return $attempt->sumgrades;
}
break;
case ATTEMPTLAST:
foreach ($attempts as $attempt) {
$final = $attempt->sumgrades;
}
return $final;
case GRADEAVERAGE:
$sum = 0;
$count = 0;
foreach ($attempts as $attempt) {
$sum += $attempt->sumgrades;
$count++;
}
return (float)$sum/$count;
default:
case GRADEHIGHEST:
$max = 0;
foreach ($attempts as $attempt) {
if ($attempt->sumgrades > $max) {
$max = $attempt->sumgrades;
}
}
return $max;
}
}
function quiz_calculate_best_attempt($quiz, $attempts) {
/// Return the attempt with the best grade for a quiz
switch ($quiz->grademethod) {
case ATTEMPTFIRST:
foreach ($attempts as $attempt) {
return $attempt;
}
break;
case GRADEAVERAGE: // need to do something with it :-)
case ATTEMPTLAST:
foreach ($attempts as $attempt) {
$final = $attempt;
}
return $final;
default:
case GRADEHIGHEST:
$max = -1;
foreach ($attempts as $attempt) {
if ($attempt->sumgrades > $max) {
$max = $attempt->sumgrades;
$maxattempt = $attempt;
}
}
return $maxattempt;
}
}
function quiz_save_attempt($quiz, $questions, $result,
$attemptnum, $finished = true) {
/// Given a quiz, a list of attempted questions and a total grade
/// this function saves EVERYTHING so it can be reconstructed later
/// if necessary.
global $USER;
global $QUIZ_QTYPES;
// First find the attempt in the database (start of attempt)
if (!$attempt = quiz_get_user_attempt_unfinished($quiz->id, $USER->id)) {
notify("Trying to save an attempt that was not started!");
return false;
}
// Not usually necessary, but there's some sort of very rare glitch
// I've seen where the number wasn't already the same. In these cases
// We upgrade the database to match the attemptnum we calculated
$attempt->attempt = $attemptnum;
// Now let's complete this record and save it
$attempt->sumgrades = $result->sumgrades;
if ($finished) {
$attempt->timefinish = time();
}
$attempt->timemodified = time();
if (!update_record("quiz_attempts", $attempt)) {
notify("Error while saving attempt");
return false;
}
// Now let's save all the questions for this attempt
foreach ($questions as $question) {
// Fetch the response record for this question...
$response = get_record('quiz_responses',
'attempt', $attempt->id, 'question', $question->id);
$response->grade = $result->details[$question->id]->grade;
if (!empty($question->response)) {
$responseanswerfield = $QUIZ_QTYPES[$question->qtype]
->convert_to_response_answer_field($question->response);
$response->answer = $responseanswerfield;
} else if (!isset($response->answer)) {
$response->answer = '';
}
if (!update_record("quiz_responses", $response)) {
notify("Error while saving response");
return false;
}
}
return $attempt;
}
function quiz_extract_correctanswers($answers, $nameprefix) {
/// Convinience function that is used by some single-response
/// question-types for determining correct answers.
$bestanswerfraction = 0.0;
$correctanswers = array();
foreach ($answers as $answer) {
if ($answer->fraction > $bestanswerfraction) {
$correctanswers = array($nameprefix.$answer->id => $answer);
$bestanswerfraction = $answer->fraction;
} else if ($answer->fraction == $bestanswerfraction) {
$correctanswers[$nameprefix.$answer->id] = $answer;
}
}
return $correctanswers;
}
function quiz_grade_responses($quiz, $questions, $attemptid=0) {
/// Given a list of questions (including ->response[] and ->maxgrade
/// on each question) this function does all the hard work of calculating the
/// score for each question, as well as a total grade for
/// the whole quiz. It returns everything in a structure
/// that lookas like this
/// ->sumgrades (sum of all grades for all questions)
/// ->grade (final grade result for the whole quiz)
/// ->percentage (Percentage of the max grade achieved)
/// ->details[]
/// The array ->details[] is indexed like the $questions argument
/// and contains scoring information per question. Each element has
/// this structure:
/// []->grade (Grade awarded on the specific question)
/// []->answers[] (result answer records for the question response(s))
/// []->correctanswers[] (answer records if question response(s) had been correct)
/// - HOWEVER, ->answers[] and ->correctanswers[] are supplied only
/// if there is a response on the question...
/// The array ->answers[] is indexed like ->response[] on its corresponding
/// element in $questions. It is the case for ->correctanswers[] when
/// there can be multiple responses per question but if there can be only one
/// response per question then all possible correctanswers will be
/// represented, indexed like the response index concatenated with the ->id
/// of its answer record.
global $QUIZ_QTYPES;
if (!$questions) {
error("No questions!");
}
$result->sumgrades = 0.0;
foreach ($questions as $qid => $question) {
if (!isset($question->response) && $attemptid) {
/// No response on the question
/// This case is common if the quiz shows a limited
/// number of questions per page.
$response = get_record('quiz_responses', 'attempt',
$attemptid, 'question', $qid);
$resultdetails->grade = $response->grade;
} else if (empty($question->qtype)) {
continue;
} else {
$resultdetails = $QUIZ_QTYPES[$question->qtype]->grade_response
($question, quiz_qtype_nameprefix($question));
// Negative grades will not do:
if (((float)($resultdetails->grade)) <= 0.0) {
$resultdetails->grade = 0.0;
// Neither will extra credit:
} else if (((float)($resultdetails->grade)) >= 1.0) {
$resultdetails->grade = $question->maxgrade;
} else {
$resultdetails->grade *= $question->maxgrade;
}
}
// if time limit is enabled and exceeded, return zero grades
if ($quiz->timelimit > 0) {
if (($quiz->timelimit + 60) <= $quiz->timesincestart) {
$resultdetails->grade = 0;
}
}
$result->sumgrades += $resultdetails->grade;
$resultdetails->grade = round($resultdetails->grade, 2);
$result->details[$qid] = $resultdetails;
}
$fraction = (float)($result->sumgrades / $quiz->sumgrades);
$result->percentage = format_float($fraction * 100.0);
$result->grade = format_float($fraction * $quiz->grade);
$result->sumgrades = round($result->sumgrades, 2);
return $result;
}
// this function creates default export filename
function default_export_filename($course,$category) {
//Take off some characters in the filename !!
$takeoff = array(" ", ":", "/", "\\", "|");
$export_word = str_replace($takeoff,"_",strtolower(get_string("exportfilename","quiz")));
//If non-translated, use "export"
if (substr($export_word,0,1) == "[") {
$export_word= "export";
}
//Calculate the date format string
$export_date_format = str_replace(" ","_",get_string("exportnameformat","quiz"));
//If non-translated, use "%Y%m%d-%H%M"
if (substr($export_date_format,0,1) == "[") {
$export_date_format = "%%Y%%m%%d-%%H%%M";
}
//Calculate the shortname
$export_shortname = clean_filename($course->shortname);
if (empty($export_shortname) or $export_shortname == '_' ) {
$export_shortname = $course->id;
}
//Calculate the category name
$export_categoryname = clean_filename($category->name);
//Calculate the final export filename
//The export word
$export_name = $export_word."-";
//The shortname
$export_name .= strtolower($export_shortname)."-";
//The category name
$export_name .= strtolower($export_categoryname)."-";
//The date format
$export_name .= userdate(time(),$export_date_format,99,false);
//The extension - no extension, supplied by format
// $export_name .= ".txt";
return $export_name;
}
// function to read all questions for category into big array
// added by Howard Miller June 2004
function get_questions_category( $category ) {
// questions will be added to an array
$qresults = array();
// get the list of questions for the category
if ($questions = get_records("quiz_questions","category",$category->id)) {
// iterate through questions, getting stuff we need
foreach($questions as $question) {
$new_question = get_question_data( $question );
$qresults[] = $new_question;
}
}
return $qresults;
}
// function to read single question, parameter is object view of
// quiz_categories record, results is a combined object
// defined as follows...
// ->id quiz_questions id
// ->category category
// ->name q name
// ->questiontext
// ->image
// ->qtype see defines at the top of this file
// ->stamp not too sure
// ->version not sure
// ----SHORTANSWER
// ->usecase
// ->answers array of answers
// ----TRUEFALSE
// ->trueanswer truefalse answer
// ->falseanswer truefalse answer
// ----MULTICHOICE
// ->layout
// ->single many or just one correct answer
// ->answers array of answer objects
// ----NUMERIC
// ->min minimum answer span
// ->max maximum answer span
// ->answer single answer
// ----MATCH
// ->subquestions array of sub questions
// ---->questiontext
// ---->answertext
function get_question_data( $question ) {
// what to do next depends of question type (qtype)
switch ($question->qtype) {
case SHORTANSWER:
$shortanswer = get_record("quiz_shortanswer","question",$question->id);
$question->usecase = $shortanswer->usecase;
$question->answers = get_exp_answers( $question->id );
break;
case TRUEFALSE:
if (!$truefalse = get_record("quiz_truefalse","question",$question->id)) {
error( "quiz_truefalse record $question->id not found" );
}
$question->trueanswer = get_exp_answer( $truefalse->trueanswer );
$question->falseanswer = get_exp_answer( $truefalse->falseanswer );
break;
case MULTICHOICE:
if (!$multichoice = get_record("quiz_multichoice","question",$question->id)) {
error( "quiz_multichoice $question->id not found" );
}
$question->layout = $multichoice->layout;
$question->single = $multichoice->single;
$question->answers = get_exp_answers( $multichoice->question );
break;
case NUMERICAL:
if (!$numeric = get_record("quiz_numerical","question",$question->id)) {
error( "quiz_numerical $question->id not found" );
}
$question->min = $numeric->min;
$question->max = $numeric->max;
$question->answer = get_exp_answer( $numeric->answer );
break;
case MATCH:
if (!$subquestions = get_records("quiz_match_sub","question",$question->id)) {
error( "quiz_match_sub $question->id not found" );
}
$question->subquestions = $subquestions;
break;
case DESCRIPTION:
// nothing to do
break;
case MULTIANSWER:
// nothing to do
break;
case RANDOM:
// nothing to do
break;
default:
notify("No handler for question type $question->qtype in get_question");
}
return $question;
}
// function to return single answer
// ->id answer id
// ->question question number
// ->answer
// ->fraction
// ->feedback
function get_exp_answer( $id ) {
if (!$answer = get_record("quiz_answers","id",$id )) {
error( "quiz_answers record $id not found" );
}
return $answer;
}
// function to return array of answers for export
function get_exp_answers( $question_num ) {
if (!$answers = get_records("quiz_answers","question",$question_num)) {
error( "quiz_answers question $question_num not found" );
}
return $answers;
}
function quiz_categorylist($categoryid) {
// returns a comma separated list of ids of the category and all subcategories
$categorylist = $categoryid;
if ($subcategories = get_records('quiz_categories', 'parent', $categoryid, 'sortorder ASC', 'id, id')) {
foreach ($subcategories as $subcategory) {
$categorylist .= ','. quiz_categorylist($subcategory->id);
}
}
return $categorylist;
}
function quizzes_question_used($id) {
// $id = question id
// returns array of names of quizzes a question appears in
$quizlist = array();
if ($grades = get_records('quiz_question_grades', 'question', $id)) {
foreach($grades as $grade) {
$quizlist[$grade->quiz] = get_field('quiz', 'name', 'id', $grade->quiz);
}
}
return $quizlist;
}
function quiz_parse_fieldname($name, $nameprefix='question') {
$reg = array();
if (preg_match("/$nameprefix(\\d+)(\w+)/", $name, $reg)) {
return array('mode' => $reg[2], 'id' => (int)$reg[1]);
} else {
return false;
}
}
?>
|
![';
echo get_string($QUIZ_QTYPES[$question->qtype]->name(), 'quiz').'](questiontypes/';
echo $QUIZ_QTYPES[$question->qtype]->name().'/icon.gif){kind=icon}
';
if ($editlink) {
echo "