mod/lesson/view.php

   1 <?php
   2
   3 // This file is part of Moodle - http://moodle.org/
   4 //
   5 // Moodle is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // Moodle is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 /**
  19  * This page prints a particular instance of lesson
  20  *
  21  * @package mod_lesson
  22  * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
  23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or late
  24  **/
  25
  26 require_once(dirname(__FILE__) . '/../../config.php');
  27 require_once($CFG->dirroot.'/mod/lesson/locallib.php');
  28 require_once($CFG->dirroot.'/mod/lesson/view_form.php');
  29 require_once($CFG->libdir . '/completionlib.php');
  30
  31 $id      = required_param('id', PARAM_INT);             // Course Module ID
  32 $pageid  = optional_param('pageid', null, PARAM_INT);   // Lesson Page ID
  33 $edit    = optional_param('edit', -1, PARAM_BOOL);
  34 $userpassword = optional_param('userpassword','',PARAM_RAW);
  35 $backtocourse = optional_param('backtocourse', false, PARAM_RAW);
  36
  37 $cm = get_coursemodule_from_id('lesson', $id, 0, false, MUST_EXIST);
  38 $course = $DB->get_record('course', array('id' => $cm->course), '*', MUST_EXIST);
  39 $lesson = new lesson($DB->get_record('lesson', array('id' => $cm->instance), '*', MUST_EXIST));
  40
  41 require_login($course, false, $cm);
  42
  43 if ($backtocourse) {
  44     redirect(new moodle_url('/course/view.php', array('id'=>$course->id)));
  45 }
  46
  47 // Mark as viewed
  48 $completion = new completion_info($course);
  49 $completion->set_module_viewed($cm);
  50
  51 $url = new moodle_url('/mod/lesson/view.php', array('id'=>$id));
  52 if ($pageid !== null) {
  53     $url->param('pageid', $pageid);
  54 }
  55 $PAGE->set_url($url);
  56
  57 $context = context_module::instance($cm->id);
  58 $canmanage = has_capability('mod/lesson:manage', $context);
  59
  60 $lessonoutput = $PAGE->get_renderer('mod_lesson');
  61
  62 $reviewmode = false;
  63 $userhasgrade = $DB->count_records("lesson_grades", array("lessonid"=>$lesson->id, "userid"=>$USER->id));
  64 if ($userhasgrade && !$lesson->retake) {
  65     $reviewmode = true;
  66 }
  67
  68 /// Check these for students only TODO: Find a better method for doing this!
  69 ///     Check lesson availability
  70 ///     Check for password
  71 ///     Check dependencies
  72 ///     Check for high scores
  73 if (!$canmanage) {
  74     if (!$lesson->is_accessible()) {  // Deadline restrictions
  75         echo $lessonoutput->header($lesson, $cm, '', false, null, get_string('notavailable'));
  76         if ($lesson->deadline != 0 && time() > $lesson->deadline) {
  77             echo $lessonoutput->lesson_inaccessible(get_string('lessonclosed', 'lesson', userdate($lesson->deadline)));
  78         } else {
  79             echo $lessonoutput->lesson_inaccessible(get_string('lessonopen', 'lesson', userdate($lesson->available)));
  80         }
  81         echo $lessonoutput->footer();
  82         exit();
  83     } else if ($lesson->usepassword && empty($USER->lessonloggedin[$lesson->id])) { // Password protected lesson code
  84         $correctpass = false;
  85         if (!empty($userpassword) && (($lesson->password == md5(trim($userpassword))) || ($lesson->password == trim($userpassword)))) {
  86             require_sesskey();
  87             // with or without md5 for backward compatibility (MDL-11090)
  88             $USER->lessonloggedin[$lesson->id] = true;
  89             if ($lesson->highscores) {
  90                 // Logged in - redirect so we go through all of these checks before starting the lesson.
  91                 redirect("$CFG->wwwroot/mod/lesson/view.php?id=$cm->id");
  92             }
  93         } else {
  94             echo $lessonoutput->header($lesson, $cm, '', false, null, get_string('passwordprotectedlesson', 'lesson', format_string($lesson->name)));
  95             echo $lessonoutput->login_prompt($lesson, $userpassword !== '');
  96             echo $lessonoutput->footer();
  97             exit();
  98         }
  99     } else if ($lesson->dependency) { // check for dependencies
 100         if ($dependentlesson = $DB->get_record('lesson', array('id' => $lesson->dependency))) {
 101             // lesson exists, so we can proceed
 102             $conditions = unserialize($lesson->conditions);
 103             // assume false for all
 104             $errors = array();
 105
 106             // check for the timespent condition
 107             if ($conditions->timespent) {
 108                 $timespent = false;
 109                 if ($attempttimes = $DB->get_records('lesson_timer', array("userid"=>$USER->id, "lessonid"=>$dependentlesson->id))) {
 110                     // go through all the times and test to see if any of them satisfy the condition
 111                     foreach($attempttimes as $attempttime) {
 112                         $duration = $attempttime->lessontime - $attempttime->starttime;
 113                         if ($conditions->timespent < $duration/60) {
 114                             $timespent = true;
 115                         }
 116                     }
 117                 }
 118                 if (!$timespent) {
 119                     $errors[] = get_string('timespenterror', 'lesson', $conditions->timespent);
 120                 }
 121             }
 122
 123             // check for the gradebetterthan condition
 124             if($conditions->gradebetterthan) {
 125                 $gradebetterthan = false;
 126                 if ($studentgrades = $DB->get_records('lesson_grades', array("userid"=>$USER->id, "lessonid"=>$dependentlesson->id))) {
 127                     // go through all the grades and test to see if any of them satisfy the condition
 128                     foreach($studentgrades as $studentgrade) {
 129                         if ($studentgrade->grade >= $conditions->gradebetterthan) {
 130                             $gradebetterthan = true;
 131                         }
 132                     }
 133                 }
 134                 if (!$gradebetterthan) {
 135                     $errors[] = get_string('gradebetterthanerror', 'lesson', $conditions->gradebetterthan);
 136                 }
 137             }
 138
 139             // check for the completed condition
 140             if ($conditions->completed) {
 141                 if (!$DB->count_records('lesson_grades', array('userid'=>$USER->id, 'lessonid'=>$dependentlesson->id))) {
 142                     $errors[] = get_string('completederror', 'lesson');
 143                 }
 144             }
 145
 146             if (!empty($errors)) {  // print out the errors if any
 147                 echo $lessonoutput->header($lesson, $cm, '', false, null, get_string('completethefollowingconditions', 'lesson', format_string($lesson->name)));
 148                 echo $lessonoutput->dependancy_errors($dependentlesson, $errors);
 149                 echo $lessonoutput->footer();
 150                 exit();
 151             }
 152         }
 153     } else if ($lesson->highscores && !$lesson->practice && !optional_param('viewed', 0, PARAM_INT) && empty($pageid)) {
 154         // Display high scores before starting lesson
 155         redirect(new moodle_url('/mod/lesson/highscores.php', array("id"=>$cm->id)));
 156     }
 157 }
 158
 159     // this is called if a student leaves during a lesson
 160 if ($pageid == LESSON_UNSEENBRANCHPAGE) {
 161     $pageid = lesson_unseen_question_jump($lesson, $USER->id, $pageid);
 162 }
 163
 164 // display individual pages and their sets of answers
 165 // if pageid is EOL then the end of the lesson has been reached
 166 // for flow, changed to simple echo for flow styles, michaelp, moved lesson name and page title down
 167 $attemptflag = false;
 168 if (empty($pageid)) {
 169     // make sure there are pages to view
 170     if (!$DB->get_field('lesson_pages', 'id', array('lessonid' => $lesson->id, 'prevpageid' => 0))) {
 171         if (!$canmanage) {
 172             $lesson->add_message(get_string('lessonnotready2', 'lesson')); // a nice message to the student
 173         } else {
 174             if (!$DB->count_records('lesson_pages', array('lessonid'=>$lesson->id))) {
 175                 redirect("$CFG->wwwroot/mod/lesson/edit.php?id=$cm->id"); // no pages - redirect to add pages
 176             } else {
 177                 $lesson->add_message(get_string('lessonpagelinkingbroken', 'lesson'));  // ok, bad mojo
 178             }
 179         }
 180     }
 181
 182     // if no pageid given see if the lesson has been started
 183     $retries = $DB->count_records('lesson_grades', array("lessonid" => $lesson->id, "userid" => $USER->id));
 184     if ($retries > 0) {
 185         $attemptflag = true;
 186     }
 187
 188     if (isset($USER->modattempts[$lesson->id])) {
 189         unset($USER->modattempts[$lesson->id]);  // if no pageid, then student is NOT reviewing
 190     }
 191
 192     // If there are any questions that have been answered correctly (or not) in this attempt.
 193     $allattempts = $lesson->get_attempts($retries);
 194     if (!empty($allattempts)) {
 195         $attempt = end($allattempts);
 196         $attemptpage = $lesson->load_page($attempt->pageid);
 197         $jumpto = $DB->get_field('lesson_answers', 'jumpto', array('id' => $attempt->answerid));
 198         // convert the jumpto to a proper page id
 199         if ($jumpto == 0) {
 200             // Check if a question has been incorrectly answered AND no more attempts at it are left.
 201             $nattempts = $lesson->get_attempts($attempt->retry, false, $attempt->pageid, $USER->id);
 202             if (count($nattempts) >= $lesson->maxattempts) {
 203                 $lastpageseen = $lesson->get_next_page($attemptpage->nextpageid);
 204             } else {
 205                 $lastpageseen = $attempt->pageid;
 206             }
 207         } elseif ($jumpto == LESSON_NEXTPAGE) {
 208             $lastpageseen = $lesson->get_next_page($attemptpage->nextpageid);
 209         } else {
 210             $lastpageseen = $jumpto;
 211         }
 212     }
 213
 214     if ($branchtables = $DB->get_records('lesson_branch', array("lessonid" => $lesson->id, "userid" => $USER->id, "retry" => $retries), 'timeseen DESC')) {
 215         // in here, user has viewed a branch table
 216         $lastbranchtable = current($branchtables);
 217         if (count($allattempts) > 0) {
 218             if ($lastbranchtable->timeseen > $attempt->timeseen) {
 219                 // This branch table was viewed more recently than the question page.
 220                 $lastpageseen = $lastbranchtable->pageid;
 221             }
 222         } else {
 223             // hasnt answered any questions but has viewed a branch table
 224             $lastpageseen = $lastbranchtable->pageid;
 225         }
 226     }
 227     if (isset($lastpageseen) && $DB->count_records('lesson_attempts', array('lessonid'=>$lesson->id, 'userid'=>$USER->id, 'retry'=>$retries)) > 0) {
 228         echo $lessonoutput->header($lesson, $cm, '', false, null, get_string('leftduringtimedsession', 'lesson'));
 229         if ($lesson->timed) {
 230             if ($lesson->retake) {
 231                 $continuelink = new single_button(new moodle_url('/mod/lesson/view.php', array('id'=>$cm->id, 'pageid'=>$lesson->firstpageid, 'startlastseen'=>'no')), get_string('continue', 'lesson'), 'get');
 232                 echo '<div class="center leftduring">'.$lessonoutput->message(get_string('leftduringtimed', 'lesson'), $continuelink).'</div>';
 233             } else {
 234                 $courselink = new single_button(new moodle_url('/course/view.php', array('id'=>$PAGE->course->id)), get_string('returntocourse', 'lesson'), 'get');
 235                 echo '<div class="center leftduring">'.$lessonoutput->message(get_string('leftduringtimednoretake', 'lesson'), $courselink).'</div>';
 236             }
 237         } else {
 238             echo $lessonoutput->continue_links($lesson, $lastpageseen);
 239         }
 240         echo $lessonoutput->footer();
 241         exit();
 242     }
 243
 244     if ($attemptflag) {
 245         if (!$lesson->retake) {
 246             echo $lessonoutput->header($lesson, $cm, 'view', '', null, get_string("noretake", "lesson"));
 247             $courselink = new single_button(new moodle_url('/course/view.php', array('id'=>$PAGE->course->id)), get_string('returntocourse', 'lesson'), 'get');
 248             echo $lessonoutput->message(get_string("noretake", "lesson"), $courselink);
 249             echo $lessonoutput->footer();
 250             exit();
 251         }
 252     }
 253     // start at the first page
 254     if (!$pageid = $DB->get_field('lesson_pages', 'id', array('lessonid' => $lesson->id, 'prevpageid' => 0))) {
 255             print_error('cannotfindfirstpage', 'lesson');
 256     }
 257     /// This is the code for starting a timed test
 258     if(!isset($USER->startlesson[$lesson->id]) && !$canmanage) {
 259         $lesson->start_timer();
 260     }
 261 }
 262
 263 $currenttab = 'view';
 264 $extraeditbuttons = false;
 265 $lessonpageid = null;
 266 $timer = null;
 267
 268 if ($pageid != LESSON_EOL) {
 269     /// This is the code updates the lessontime for a timed test
 270     $startlastseen = optional_param('startlastseen', '', PARAM_ALPHA);
 271
 272     $page = $lesson->load_page($pageid);
 273     // Check if the page is of a special type and if so take any nessecary action
 274     $newpageid = $page->callback_on_view($canmanage);
 275     if (is_numeric($newpageid)) {
 276         $page = $lesson->load_page($newpageid);
 277     }
 278
 279     // Trigger module viewed event.
 280     $event = \mod_lesson\event\course_module_viewed::create(array(
 281         'objectid' => $lesson->id,
 282         'context' => $context
 283     ));
 284     $event->add_record_snapshot('course_modules', $cm);
 285     $event->add_record_snapshot('course', $course);
 286     $event->trigger();
 287
 288     // This is where several messages (usually warnings) are displayed
 289     // all of this is displayed above the actual page
 290
 291     // check to see if the user can see the left menu
 292     if (!$canmanage) {
 293         $lesson->displayleft = lesson_displayleftif($lesson);
 294
 295         $continue = ($startlastseen !== '');
 296         $restart  = ($continue && $startlastseen == 'yes');
 297         $timer = $lesson->update_timer($continue, $restart);
 298
 299         if ($lesson->timed) {
 300             $timeleft = ($timer->starttime + $lesson->maxtime * 60) - time();
 301             if ($timeleft <= 0) {
 302                 // Out of time
 303                 $lesson->add_message(get_string('eolstudentoutoftime', 'lesson'));
 304                 redirect(new moodle_url('/mod/lesson/view.php', array('id'=>$cm->id,'pageid'=>LESSON_EOL, 'outoftime'=>'normal')));
 305                 die; // Shouldn't be reached, but make sure
 306             } else if ($timeleft < 60) {
 307                 // One minute warning
 308                 $lesson->add_message(get_string('studentoneminwarning', 'lesson'));
 309             }
 310         }
 311
 312         if ($page->qtype == LESSON_PAGE_BRANCHTABLE && $lesson->minquestions) {
 313             // tell student how many questions they have seen, how many are required and their grade
 314             $ntries = $DB->count_records("lesson_grades", array("lessonid"=>$lesson->id, "userid"=>$USER->id));
 315             $gradeinfo = lesson_grade($lesson, $ntries);
 316             if ($gradeinfo->attempts) {
 317                 if ($gradeinfo->nquestions < $lesson->minquestions) {
 318                     $a = new stdClass;
 319                     $a->nquestions   = $gradeinfo->nquestions;
 320                     $a->minquestions = $lesson->minquestions;
 321                     $lesson->add_message(get_string('numberofpagesviewednotice', 'lesson', $a));
 322                 }
 323
 324                 $a = new stdClass;
 325                 $a->grade = number_format($gradeinfo->grade * $lesson->grade / 100, 1);
 326                 $a->total = $lesson->grade;
 327                 if (!$reviewmode && !$lesson->retake){
 328                     $lesson->add_message(get_string("numberofcorrectanswers", "lesson", $gradeinfo->earned), 'notify');
 329                     $lesson->add_message(get_string('yourcurrentgradeisoutof', 'lesson', $a), 'notify');
 330                 }
 331             }
 332         }
 333     } else {
 334         $timer = null;
 335         if ($lesson->timed) {
 336             $lesson->add_message(get_string('teachertimerwarning', 'lesson'));
 337         }
 338         if (lesson_display_teacher_warning($lesson)) {
 339             // This is the warning msg for teachers to inform them that cluster
 340             // and unseen does not work while logged in as a teacher
 341             $warningvars = new stdClass();
 342             $warningvars->cluster = get_string('clusterjump', 'lesson');
 343             $warningvars->unseen = get_string('unseenpageinbranch', 'lesson');
 344             $lesson->add_message(get_string('teacherjumpwarning', 'lesson', $warningvars));
 345         }
 346     }
 347
 348     $PAGE->set_subpage($page->id);
 349     $currenttab = 'view';
 350     $extraeditbuttons = true;
 351     $lessonpageid = $page->id;
 352     $extrapagetitle = $page->title;
 353
 354     if (($edit != -1) && $PAGE->user_allowed_editing()) {
 355         $USER->editing = $edit;
 356     }
 357
 358     if (is_array($page->answers) && count($page->answers)>0) {
 359         // this is for modattempts option.  Find the users previous answer to this page,
 360         //   and then display it below in answer processing
 361         if (isset($USER->modattempts[$lesson->id])) {
 362             $retries = $DB->count_records('lesson_grades', array("lessonid"=>$lesson->id, "userid"=>$USER->id));
 363             if (!$attempts = $lesson->get_attempts($retries-1, false, $page->id)) {
 364                 print_error('cannotfindpreattempt', 'lesson');
 365             }
 366             $attempt = end($attempts);
 367             $USER->modattempts[$lesson->id] = $attempt;
 368         } else {
 369             $attempt = false;
 370         }
 371         $lessoncontent = $lessonoutput->display_page($lesson, $page, $attempt);
 372     } else {
 373         $data = new stdClass;
 374         $data->id = $PAGE->cm->id;
 375         $data->pageid = $page->id;
 376         $data->newpageid = $lesson->get_next_page($page->nextpageid);
 377
 378         $customdata = array(
 379             'title'     => $page->title,
 380             'contents'  => $page->get_contents()
 381         );
 382         $mform = new lesson_page_without_answers($CFG->wwwroot.'/mod/lesson/continue.php', $customdata);
 383         $mform->set_data($data);
 384         ob_start();
 385         $mform->display();
 386         $lessoncontent = ob_get_contents();
 387         ob_end_clean();
 388     }
 389
 390     lesson_add_fake_blocks($PAGE, $cm, $lesson, $timer);
 391     echo $lessonoutput->header($lesson, $cm, $currenttab, $extraeditbuttons, $lessonpageid, $extrapagetitle);
 392     if ($attemptflag) {
 393         // We are using level 3 header because attempt heading is a sub-heading of lesson title (MDL-30911).
 394         echo $OUTPUT->heading(get_string('attempt', 'lesson', $retries), 3);
 395     }
 396     /// This calculates and prints the ongoing score
 397     if ($lesson->ongoing && !empty($pageid) && !$reviewmode) {
 398         echo $lessonoutput->ongoing_score($lesson);
 399     }
 400     if ($lesson->displayleft) {
 401         echo '<a name="maincontent" id="maincontent" title="' . get_string('anchortitle', 'lesson') . '"></a>';
 402     }
 403     echo $lessoncontent;
 404     echo $lessonoutput->progress_bar($lesson);
 405     echo $lessonoutput->footer();
 406
 407 } else {
 408
 409     $lessoncontent = '';
 410     // end of lesson reached work out grade
 411     // Used to check to see if the student ran out of time
 412     $outoftime = optional_param('outoftime', '', PARAM_ALPHA);
 413
 414     $ntries = $DB->count_records("lesson_grades", array("lessonid"=>$lesson->id, "userid"=>$USER->id));
 415     if (isset($USER->modattempts[$lesson->id])) {
 416         $ntries--;  // need to look at the old attempts :)
 417     }
 418
 419     $gradelesson = true;
 420     $gradeinfo = lesson_grade($lesson, $ntries);
 421     if ($lesson->custom && !$canmanage) {
 422         // Before we calculate the custom score make sure they answered the minimum
 423         // number of questions. We only need to do this for custom scoring as we can
 424         // not get the miniumum score the user should achieve. If we are not using
 425         // custom scoring (so all questions are valued as 1) then we simply check if
 426         // they answered more than the minimum questions, if not, we mark it out of the
 427         // number specified in the minimum questions setting - which is done in lesson_grade().
 428         // Get the number of answers given.
 429         if ($gradeinfo->nquestions < $lesson->minquestions) {
 430             $gradelesson = false;
 431             $a = new stdClass;
 432             $a->nquestions = $gradeinfo->nquestions;
 433             $a->minquestions = $lesson->minquestions;
 434             $lessoncontent .= $OUTPUT->box_start('generalbox boxaligncenter');
 435             $lesson->add_message(get_string('numberofpagesviewednotice', 'lesson', $a));
 436         }
 437     }
 438     if ($gradelesson) {
 439         // We are using level 3 header because the page title is a sub-heading of lesson title (MDL-30911).
 440         $lessoncontent .= $OUTPUT->heading(get_string("congratulations", "lesson"), 3);
 441         $lessoncontent .= $OUTPUT->box_start('generalbox boxaligncenter');
 442     }
 443     if (!$canmanage) {
 444         if ($gradelesson) {
 445             // Update the clock / get time information for this user.
 446             $lesson->stop_timer();
 447             $gradeinfo = lesson_grade($lesson, $ntries);
 448
 449             if ($gradeinfo->attempts) {
 450                 if (!$lesson->custom) {
 451                     $lessoncontent .= $lessonoutput->paragraph(get_string("numberofpagesviewed", "lesson", $gradeinfo->nquestions), 'center');
 452                     if ($lesson->minquestions) {
 453                         if ($gradeinfo->nquestions < $lesson->minquestions) {
 454                             // print a warning and set nviewed to minquestions
 455                             $lessoncontent .= $lessonoutput->paragraph(get_string("youshouldview", "lesson", $lesson->minquestions), 'center');
 456                         }
 457                     }
 458                     $lessoncontent .= $lessonoutput->paragraph(get_string("numberofcorrectanswers", "lesson", $gradeinfo->earned), 'center');
 459                 }
 460                 $a = new stdClass;
 461                 $a->score = $gradeinfo->earned;
 462                 $a->grade = $gradeinfo->total;
 463                 if ($gradeinfo->nmanual) {
 464                     $a->tempmaxgrade = $gradeinfo->total - $gradeinfo->manualpoints;
 465                     $a->essayquestions = $gradeinfo->nmanual;
 466                     $lessoncontent .= $OUTPUT->box(get_string("displayscorewithessays", "lesson", $a), 'center');
 467                 } else {
 468                     $lessoncontent .= $OUTPUT->box(get_string("displayscorewithoutessays", "lesson", $a), 'center');
 469                 }
 470                 $a = new stdClass;
 471                 $a->grade = number_format($gradeinfo->grade * $lesson->grade / 100, 1);
 472                 $a->total = $lesson->grade;
 473                 $lessoncontent .= $lessonoutput->paragraph(get_string("yourcurrentgradeisoutof", "lesson", $a), 'center');
 474
 475                 $grade = new stdClass();
 476                 $grade->lessonid = $lesson->id;
 477                 $grade->userid = $USER->id;
 478                 $grade->grade = $gradeinfo->grade;
 479                 $grade->completed = time();
 480                 if (!$lesson->practice) {
 481                     if (isset($USER->modattempts[$lesson->id])) { // if reviewing, make sure update old grade record
 482                         if (!$grades = $DB->get_records("lesson_grades", array("lessonid" => $lesson->id, "userid" => $USER->id), "completed DESC", '*', 0, 1)) {
 483                             print_error('cannotfindgrade', 'lesson');
 484                         }
 485                         $oldgrade = array_shift($grades);
 486                         $grade->id = $oldgrade->id;
 487                         $DB->update_record("lesson_grades", $grade);
 488                     } else {
 489                         $newgradeid = $DB->insert_record("lesson_grades", $grade);
 490                     }
 491                 } else {
 492                     $DB->delete_records("lesson_attempts", array("lessonid" => $lesson->id, "userid" => $USER->id, "retry" => $ntries));
 493                 }
 494             } else {
 495                 if ($lesson->timed) {
 496                     if ($outoftime == 'normal') {
 497                         $grade = new stdClass();
 498                         $grade->lessonid = $lesson->id;
 499                         $grade->userid = $USER->id;
 500                         $grade->grade = 0;
 501                         $grade->completed = time();
 502                         if (!$lesson->practice) {
 503                             $newgradeid = $DB->insert_record("lesson_grades", $grade);
 504                         }
 505                         $lessoncontent .= get_string("eolstudentoutoftimenoanswers", "lesson");
 506                     }
 507                 } else {
 508                     $lessoncontent .= get_string("welldone", "lesson");
 509                 }
 510             }
 511
 512             // update central gradebook
 513             lesson_update_grades($lesson, $USER->id);
 514         }
 515     } else {
 516         // display for teacher
 517         $lessoncontent .= $lessonoutput->paragraph(get_string("displayofgrade", "lesson"), 'center');
 518     }
 519     $lessoncontent .= $OUTPUT->box_end(); //End of Lesson button to Continue.
 520
 521     // high scores code
 522     if ($lesson->highscores && !$canmanage && !$lesson->practice) {
 523         $lessoncontent .= $OUTPUT->box_start('center');
 524         if ($grades = $DB->get_records("lesson_grades", array("lessonid" => $lesson->id), "completed")) {
 525             $madeit = false;
 526             if ($highscores = $DB->get_records("lesson_high_scores", array("lessonid" => $lesson->id))) {
 527                 // get all the high scores into an array
 528                 $topscores = array();
 529                 $uniquescores = array();
 530                 foreach ($highscores as $highscore) {
 531                     $grade = $grades[$highscore->gradeid]->grade;
 532                     $topscores[] = $grade;
 533                     $uniquescores[$grade] = 1;
 534                 }
 535                 // sort to find the lowest score
 536                 sort($topscores);
 537                 $lowscore = $topscores[0];
 538
 539                 if ($gradeinfo->grade >= $lowscore || count($uniquescores) <= $lesson->maxhighscores) {
 540                     $madeit = true;
 541                 }
 542             }
 543             if (!$highscores or $madeit) {
 544                 $lessoncontent .= $lessonoutput->paragraph(get_string("youmadehighscore", "lesson", $lesson->maxhighscores), 'center');
 545                 $aurl = new moodle_url('/mod/lesson/highscores.php', array('id'=>$PAGE->cm->id, 'sesskey'=>sesskey()));
 546                 $lessoncontent .= $OUTPUT->single_button($aurl, get_string('clicktopost', 'lesson'));
 547             } else {
 548                 $lessoncontent .= get_string("nothighscore", "lesson", $lesson->maxhighscores)."<br />";
 549             }
 550         }
 551         $url = new moodle_url('/mod/lesson/highscores.php', array('id'=>$PAGE->cm->id, 'link'=>'1'));
 552         $lessoncontent .= html_writer::link($url, get_string('viewhighscores', 'lesson'), array('class'=>'centerpadded lessonbutton standardbutton'));
 553         $lessoncontent .= $OUTPUT->box_end();
 554     }
 555
 556     if ($lesson->modattempts && !$canmanage) {
 557         // make sure if the student is reviewing, that he/she sees the same pages/page path that he/she saw the first time
 558         // look at the attempt records to find the first QUESTION page that the user answered, then use that page id
 559         // to pass to view again.  This is slick cause it wont call the empty($pageid) code
 560         // $ntries is decremented above
 561         if (!$attempts = $lesson->get_attempts($ntries)) {
 562             $attempts = array();
 563             $url = new moodle_url('/mod/lesson/view.php', array('id'=>$PAGE->cm->id));
 564         } else {
 565             $firstattempt = current($attempts);
 566             $pageid = $firstattempt->pageid;
 567             // IF the student wishes to review, need to know the last question page that the student answered.  This will help to make
 568             // sure that the student can leave the lesson via pushing the continue button.
 569             $lastattempt = end($attempts);
 570             $USER->modattempts[$lesson->id] = $lastattempt->pageid;
 571
 572             $url = new moodle_url('/mod/lesson/view.php', array('id'=>$PAGE->cm->id, 'pageid'=>$pageid));
 573         }
 574         $lessoncontent .= html_writer::link($url, get_string('reviewlesson', 'lesson'), array('class' => 'centerpadded lessonbutton standardbutton'));
 575     } elseif ($lesson->modattempts && $canmanage) {
 576         $lessoncontent .= $lessonoutput->paragraph(get_string("modattemptsnoteacher", "lesson"), 'centerpadded');
 577     }
 578
 579     if ($lesson->activitylink) {
 580         $lessoncontent .= $lesson->link_for_activitylink();
 581     }
 582
 583     $url = new moodle_url('/course/view.php', array('id'=>$course->id));
 584     $lessoncontent .= html_writer::link($url, get_string('returnto', 'lesson', format_string($course->fullname, true)), array('class'=>'centerpadded lessonbutton standardbutton'));
 585
 586     if (has_capability('gradereport/user:view', context_course::instance($course->id))
 587             && $course->showgrades && $lesson->grade != 0 && !$lesson->practice) {
 588         $url = new moodle_url('/grade/index.php', array('id' => $course->id));
 589         $lessoncontent .= html_writer::link($url, get_string('viewgrades', 'lesson'),
 590             array('class' => 'centerpadded lessonbutton standardbutton'));
 591     }
 592
 593     lesson_add_fake_blocks($PAGE, $cm, $lesson, $timer);
 594     echo $lessonoutput->header($lesson, $cm, $currenttab, $extraeditbuttons, $lessonpageid, get_string("congratulations", "lesson"));
 595     echo $lessoncontent;
 596     echo $lessonoutput->footer();
 597 }