forked from moodle/moodle
-
Notifications
You must be signed in to change notification settings - Fork 0
/
attemptlib.php
2597 lines (2277 loc) · 96.3 KB
/
attemptlib.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* Back-end code for handling data about quizzes and the current user's attempt.
*
* There are classes for loading all the information about a quiz and attempts,
* and for displaying the navigation panel.
*
* @package mod_quiz
* @copyright 2008 onwards Tim Hunt
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
/**
* Class for quiz exceptions. Just saves a couple of arguments on the
* constructor for a moodle_exception.
*
* @copyright 2008 Tim Hunt
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @since Moodle 2.0
*/
class moodle_quiz_exception extends moodle_exception {
public function __construct($quizobj, $errorcode, $a = null, $link = '', $debuginfo = null) {
if (!$link) {
$link = $quizobj->view_url();
}
parent::__construct($errorcode, 'quiz', $link, $a, $debuginfo);
}
}
/**
* A class encapsulating a quiz and the questions it contains, and making the
* information available to scripts like view.php.
*
* Initially, it only loads a minimal amout of information about each question - loading
* extra information only when necessary or when asked. The class tracks which questions
* are loaded.
*
* @copyright 2008 Tim Hunt
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @since Moodle 2.0
*/
class quiz {
/** @var stdClass the course settings from the database. */
protected $course;
/** @var stdClass the course_module settings from the database. */
protected $cm;
/** @var stdClass the quiz settings from the database. */
protected $quiz;
/** @var context the quiz context. */
protected $context;
/** @var array of questions augmented with slot information. */
protected $questions = null;
/** @var array of quiz_section rows. */
protected $sections = null;
/** @var quiz_access_manager the access manager for this quiz. */
protected $accessmanager = null;
/** @var bool whether the current user has capability mod/quiz:preview. */
protected $ispreviewuser = null;
// Constructor =============================================================
/**
* Constructor, assuming we already have the necessary data loaded.
*
* @param object $quiz the row from the quiz table.
* @param object $cm the course_module object for this quiz.
* @param object $course the row from the course table for the course we belong to.
* @param bool $getcontext intended for testing - stops the constructor getting the context.
*/
public function __construct($quiz, $cm, $course, $getcontext = true) {
$this->quiz = $quiz;
$this->cm = $cm;
$this->quiz->cmid = $this->cm->id;
$this->course = $course;
if ($getcontext && !empty($cm->id)) {
$this->context = context_module::instance($cm->id);
}
}
/**
* Static function to create a new quiz object for a specific user.
*
* @param int $quizid the the quiz id.
* @param int $userid the the userid.
* @return quiz the new quiz object
*/
public static function create($quizid, $userid = null) {
global $DB;
$quiz = quiz_access_manager::load_quiz_and_settings($quizid);
$course = $DB->get_record('course', array('id' => $quiz->course), '*', MUST_EXIST);
$cm = get_coursemodule_from_instance('quiz', $quiz->id, $course->id, false, MUST_EXIST);
// Update quiz with override information.
if ($userid) {
$quiz = quiz_update_effective_access($quiz, $userid);
}
return new quiz($quiz, $cm, $course);
}
/**
* Create a {@link quiz_attempt} for an attempt at this quiz.
* @param object $attemptdata row from the quiz_attempts table.
* @return quiz_attempt the new quiz_attempt object.
*/
public function create_attempt_object($attemptdata) {
return new quiz_attempt($attemptdata, $this->quiz, $this->cm, $this->course);
}
// Functions for loading more data =========================================
/**
* Load just basic information about all the questions in this quiz.
*/
public function preload_questions() {
$this->questions = question_preload_questions(null,
'slot.maxmark, slot.id AS slotid, slot.slot, slot.page,
slot.questioncategoryid AS randomfromcategory,
slot.includingsubcategories AS randomincludingsubcategories',
'{quiz_slots} slot ON slot.quizid = :quizid AND q.id = slot.questionid',
array('quizid' => $this->quiz->id), 'slot.slot');
}
/**
* Fully load some or all of the questions for this quiz. You must call
* {@link preload_questions()} first.
*
* @param array $questionids question ids of the questions to load. null for all.
*/
public function load_questions($questionids = null) {
if ($this->questions === null) {
throw new coding_exception('You must call preload_questions before calling load_questions.');
}
if (is_null($questionids)) {
$questionids = array_keys($this->questions);
}
$questionstoprocess = array();
foreach ($questionids as $id) {
if (array_key_exists($id, $this->questions)) {
$questionstoprocess[$id] = $this->questions[$id];
}
}
get_question_options($questionstoprocess);
}
/**
* Get an instance of the {@link \mod_quiz\structure} class for this quiz.
* @return \mod_quiz\structure describes the questions in the quiz.
*/
public function get_structure() {
return \mod_quiz\structure::create_for_quiz($this);
}
// Simple getters ==========================================================
/** @return int the course id. */
public function get_courseid() {
return $this->course->id;
}
/** @return object the row of the course table. */
public function get_course() {
return $this->course;
}
/** @return int the quiz id. */
public function get_quizid() {
return $this->quiz->id;
}
/** @return object the row of the quiz table. */
public function get_quiz() {
return $this->quiz;
}
/** @return string the name of this quiz. */
public function get_quiz_name() {
return $this->quiz->name;
}
/** @return int the quiz navigation method. */
public function get_navigation_method() {
return $this->quiz->navmethod;
}
/** @return int the number of attempts allowed at this quiz (0 = infinite). */
public function get_num_attempts_allowed() {
return $this->quiz->attempts;
}
/** @return int the course_module id. */
public function get_cmid() {
return $this->cm->id;
}
/** @return object the course_module object. */
public function get_cm() {
return $this->cm;
}
/** @return object the module context for this quiz. */
public function get_context() {
return $this->context;
}
/**
* @return bool wether the current user is someone who previews the quiz,
* rather than attempting it.
*/
public function is_preview_user() {
if (is_null($this->ispreviewuser)) {
$this->ispreviewuser = has_capability('mod/quiz:preview', $this->context);
}
return $this->ispreviewuser;
}
/**
* @return whether any questions have been added to this quiz.
*/
public function has_questions() {
if ($this->questions === null) {
$this->preload_questions();
}
return !empty($this->questions);
}
/**
* @param int $id the question id.
* @return object the question object with that id.
*/
public function get_question($id) {
return $this->questions[$id];
}
/**
* @param array $questionids question ids of the questions to load. null for all.
*/
public function get_questions($questionids = null) {
if (is_null($questionids)) {
$questionids = array_keys($this->questions);
}
$questions = array();
foreach ($questionids as $id) {
if (!array_key_exists($id, $this->questions)) {
throw new moodle_exception('cannotstartmissingquestion', 'quiz', $this->view_url());
}
$questions[$id] = $this->questions[$id];
$this->ensure_question_loaded($id);
}
return $questions;
}
/**
* Get all the sections in this quiz.
* @return array 0, 1, 2, ... => quiz_sections row from the database.
*/
public function get_sections() {
global $DB;
if ($this->sections === null) {
$this->sections = array_values($DB->get_records('quiz_sections',
array('quizid' => $this->get_quizid()), 'firstslot'));
}
return $this->sections;
}
/**
* Return quiz_access_manager and instance of the quiz_access_manager class
* for this quiz at this time.
* @param int $timenow the current time as a unix timestamp.
* @return quiz_access_manager and instance of the quiz_access_manager class
* for this quiz at this time.
*/
public function get_access_manager($timenow) {
if (is_null($this->accessmanager)) {
$this->accessmanager = new quiz_access_manager($this, $timenow,
has_capability('mod/quiz:ignoretimelimits', $this->context, null, false));
}
return $this->accessmanager;
}
/**
* Wrapper round the has_capability funciton that automatically passes in the quiz context.
*/
public function has_capability($capability, $userid = null, $doanything = true) {
return has_capability($capability, $this->context, $userid, $doanything);
}
/**
* Wrapper round the require_capability funciton that automatically passes in the quiz context.
*/
public function require_capability($capability, $userid = null, $doanything = true) {
return require_capability($capability, $this->context, $userid, $doanything);
}
// URLs related to this attempt ============================================
/**
* @return string the URL of this quiz's view page.
*/
public function view_url() {
global $CFG;
return $CFG->wwwroot . '/mod/quiz/view.php?id=' . $this->cm->id;
}
/**
* @return string the URL of this quiz's edit page.
*/
public function edit_url() {
global $CFG;
return $CFG->wwwroot . '/mod/quiz/edit.php?cmid=' . $this->cm->id;
}
/**
* @param int $attemptid the id of an attempt.
* @param int $page optional page number to go to in the attempt.
* @return string the URL of that attempt.
*/
public function attempt_url($attemptid, $page = 0) {
global $CFG;
$url = $CFG->wwwroot . '/mod/quiz/attempt.php?attempt=' . $attemptid;
if ($page) {
$url .= '&page=' . $page;
}
$url .= '&cmid=' . $this->get_cmid();
return $url;
}
/**
* @return string the URL of this quiz's edit page. Needs to be POSTed to with a cmid parameter.
*/
public function start_attempt_url($page = 0) {
$params = array('cmid' => $this->cm->id, 'sesskey' => sesskey());
if ($page) {
$params['page'] = $page;
}
return new moodle_url('/mod/quiz/startattempt.php', $params);
}
/**
* @param int $attemptid the id of an attempt.
* @return string the URL of the review of that attempt.
*/
public function review_url($attemptid) {
return new moodle_url('/mod/quiz/review.php', array('attempt' => $attemptid, 'cmid' => $this->get_cmid()));
}
/**
* @param int $attemptid the id of an attempt.
* @return string the URL of the review of that attempt.
*/
public function summary_url($attemptid) {
return new moodle_url('/mod/quiz/summary.php', array('attempt' => $attemptid, 'cmid' => $this->get_cmid()));
}
// Bits of content =========================================================
/**
* @param bool $notused not used.
* @return string an empty string.
* @deprecated since 3.1. This sort of functionality is now entirely handled by quiz access rules.
*/
public function confirm_start_attempt_message($notused) {
debugging('confirm_start_attempt_message is deprecated. ' .
'This sort of functionality is now entirely handled by quiz access rules.');
return '';
}
/**
* If $reviewoptions->attempt is false, meaning that students can't review this
* attempt at the moment, return an appropriate string explaining why.
*
* @param int $when One of the mod_quiz_display_options::DURING,
* IMMEDIATELY_AFTER, LATER_WHILE_OPEN or AFTER_CLOSE constants.
* @param bool $short if true, return a shorter string.
* @return string an appropraite message.
*/
public function cannot_review_message($when, $short = false) {
if ($short) {
$langstrsuffix = 'short';
$dateformat = get_string('strftimedatetimeshort', 'langconfig');
} else {
$langstrsuffix = '';
$dateformat = '';
}
if ($when == mod_quiz_display_options::DURING ||
$when == mod_quiz_display_options::IMMEDIATELY_AFTER) {
return '';
} else if ($when == mod_quiz_display_options::LATER_WHILE_OPEN && $this->quiz->timeclose &&
$this->quiz->reviewattempt & mod_quiz_display_options::AFTER_CLOSE) {
return get_string('noreviewuntil' . $langstrsuffix, 'quiz',
userdate($this->quiz->timeclose, $dateformat));
} else {
return get_string('noreview' . $langstrsuffix, 'quiz');
}
}
/**
* @param string $title the name of this particular quiz page.
* @return array the data that needs to be sent to print_header_simple as the $navigation
* parameter.
*/
public function navigation($title) {
global $PAGE;
$PAGE->navbar->add($title);
return '';
}
// Private methods =========================================================
/**
* Check that the definition of a particular question is loaded, and if not throw an exception.
* @param $id a questionid.
*/
protected function ensure_question_loaded($id) {
if (isset($this->questions[$id]->_partiallyloaded)) {
throw new moodle_quiz_exception($this, 'questionnotloaded', $id);
}
}
/**
* Return all the question types used in this quiz.
*
* @param boolean $includepotential if the quiz include random questions, setting this flag to true will make the function to
* return all the possible question types in the random questions category
* @return array a sorted array including the different question types
* @since Moodle 3.1
*/
public function get_all_question_types_used($includepotential = false) {
$questiontypes = array();
// To control if we need to look in categories for questions.
$qcategories = array();
// We must be careful with random questions, if we find a random question we must assume that the quiz may content
// any of the questions in the referenced category (or subcategories).
foreach ($this->get_questions() as $questiondata) {
if ($questiondata->qtype == 'random' and $includepotential) {
$includesubcategories = (bool) $questiondata->questiontext;
if (!isset($qcategories[$questiondata->category])) {
$qcategories[$questiondata->category] = false;
}
if ($includesubcategories) {
$qcategories[$questiondata->category] = true;
}
} else {
if (!in_array($questiondata->qtype, $questiontypes)) {
$questiontypes[] = $questiondata->qtype;
}
}
}
if (!empty($qcategories)) {
// We have to look for all the question types in these categories.
$categoriestolook = array();
foreach ($qcategories as $cat => $includesubcats) {
if ($includesubcats) {
$categoriestolook = array_merge($categoriestolook, question_categorylist($cat));
} else {
$categoriestolook[] = $cat;
}
}
$questiontypesincategories = question_bank::get_all_question_types_in_categories($categoriestolook);
$questiontypes = array_merge($questiontypes, $questiontypesincategories);
}
$questiontypes = array_unique($questiontypes);
sort($questiontypes);
return $questiontypes;
}
}
/**
* This class extends the quiz class to hold data about the state of a particular attempt,
* in addition to the data about the quiz.
*
* @copyright 2008 Tim Hunt
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @since Moodle 2.0
*/
class quiz_attempt {
/** @var string to identify the in progress state. */
const IN_PROGRESS = 'inprogress';
/** @var string to identify the overdue state. */
const OVERDUE = 'overdue';
/** @var string to identify the finished state. */
const FINISHED = 'finished';
/** @var string to identify the abandoned state. */
const ABANDONED = 'abandoned';
/** @var int maximum number of slots in the quiz for the review page to default to show all. */
const MAX_SLOTS_FOR_DEFAULT_REVIEW_SHOW_ALL = 50;
/** @var quiz object containing the quiz settings. */
protected $quizobj;
/** @var stdClass the quiz_attempts row. */
protected $attempt;
/** @var question_usage_by_activity the question usage for this quiz attempt. */
protected $quba;
/**
* @var array of slot information. These objects contain ->slot (int),
* ->requireprevious (bool), ->questionids (int) the original question for random questions,
* ->firstinsection (bool), ->section (stdClass from $this->sections).
* This does not contain page - get that from {@link get_question_page()} -
* or maxmark - get that from $this->quba.
*/
protected $slots;
/** @var array of quiz_sections rows, with a ->lastslot field added. */
protected $sections;
/** @var array page no => array of slot numbers on the page in order. */
protected $pagelayout;
/** @var array slot => displayed question number for this slot. (E.g. 1, 2, 3 or 'i'.) */
protected $questionnumbers;
/** @var array slot => page number for this slot. */
protected $questionpages;
/** @var mod_quiz_display_options cache for the appropriate review options. */
protected $reviewoptions = null;
// Constructor =============================================================
/**
* Constructor assuming we already have the necessary data loaded.
*
* @param object $attempt the row of the quiz_attempts table.
* @param object $quiz the quiz object for this attempt and user.
* @param object $cm the course_module object for this quiz.
* @param object $course the row from the course table for the course we belong to.
* @param bool $loadquestions (optional) if true, the default, load all the details
* of the state of each question. Else just set up the basic details of the attempt.
*/
public function __construct($attempt, $quiz, $cm, $course, $loadquestions = true) {
global $DB;
$this->attempt = $attempt;
$this->quizobj = new quiz($quiz, $cm, $course);
if (!$loadquestions) {
return;
}
$this->quba = question_engine::load_questions_usage_by_activity($this->attempt->uniqueid);
$this->slots = $DB->get_records('quiz_slots',
array('quizid' => $this->get_quizid()), 'slot',
'slot, requireprevious, questionid, includingsubcategories');
$this->sections = array_values($DB->get_records('quiz_sections',
array('quizid' => $this->get_quizid()), 'firstslot'));
$this->link_sections_and_slots();
$this->determine_layout();
$this->number_questions();
}
/**
* Used by {create()} and {create_from_usage_id()}.
* @param array $conditions passed to $DB->get_record('quiz_attempts', $conditions).
*/
protected static function create_helper($conditions) {
global $DB;
$attempt = $DB->get_record('quiz_attempts', $conditions, '*', MUST_EXIST);
$quiz = quiz_access_manager::load_quiz_and_settings($attempt->quiz);
$course = $DB->get_record('course', array('id' => $quiz->course), '*', MUST_EXIST);
$cm = get_coursemodule_from_instance('quiz', $quiz->id, $course->id, false, MUST_EXIST);
// Update quiz with override information.
$quiz = quiz_update_effective_access($quiz, $attempt->userid);
return new quiz_attempt($attempt, $quiz, $cm, $course);
}
/**
* Static function to create a new quiz_attempt object given an attemptid.
*
* @param int $attemptid the attempt id.
* @return quiz_attempt the new quiz_attempt object
*/
public static function create($attemptid) {
return self::create_helper(array('id' => $attemptid));
}
/**
* Static function to create a new quiz_attempt object given a usage id.
*
* @param int $usageid the attempt usage id.
* @return quiz_attempt the new quiz_attempt object
*/
public static function create_from_usage_id($usageid) {
return self::create_helper(array('uniqueid' => $usageid));
}
/**
* @param string $state one of the state constants like IN_PROGRESS.
* @return string the human-readable state name.
*/
public static function state_name($state) {
return quiz_attempt_state_name($state);
}
/**
* Let each slot know which section it is part of.
*/
protected function link_sections_and_slots() {
foreach ($this->sections as $i => $section) {
if (isset($this->sections[$i + 1])) {
$section->lastslot = $this->sections[$i + 1]->firstslot - 1;
} else {
$section->lastslot = count($this->slots);
}
for ($slot = $section->firstslot; $slot <= $section->lastslot; $slot += 1) {
$this->slots[$slot]->section = $section;
}
}
}
/**
* Parse attempt->layout to populate the other arrays the represent the layout.
*/
protected function determine_layout() {
$this->pagelayout = array();
// Break up the layout string into pages.
$pagelayouts = explode(',0', $this->attempt->layout);
// Strip off any empty last page (normally there is one).
if (end($pagelayouts) == '') {
array_pop($pagelayouts);
}
// File the ids into the arrays.
// Tracking which is the first slot in each section in this attempt is
// trickier than you might guess, since the slots in this section
// may be shuffled, so $section->firstslot (the lowest numbered slot in
// the section) may not be the first one.
$unseensections = $this->sections;
$this->pagelayout = array();
foreach ($pagelayouts as $page => $pagelayout) {
$pagelayout = trim($pagelayout, ',');
if ($pagelayout == '') {
continue;
}
$this->pagelayout[$page] = explode(',', $pagelayout);
foreach ($this->pagelayout[$page] as $slot) {
$sectionkey = array_search($this->slots[$slot]->section, $unseensections);
if ($sectionkey !== false) {
$this->slots[$slot]->firstinsection = true;
unset($unseensections[$sectionkey]);
} else {
$this->slots[$slot]->firstinsection = false;
}
}
}
}
/**
* Work out the number to display for each question/slot.
*/
protected function number_questions() {
$number = 1;
foreach ($this->pagelayout as $page => $slots) {
foreach ($slots as $slot) {
if ($length = $this->is_real_question($slot)) {
$this->questionnumbers[$slot] = $number;
$number += $length;
} else {
$this->questionnumbers[$slot] = get_string('infoshort', 'quiz');
}
$this->questionpages[$slot] = $page;
}
}
}
/**
* If the given page number is out of range (before the first page, or after
* the last page, chnage it to be within range).
* @param int $page the requested page number.
* @return int a safe page number to use.
*/
public function force_page_number_into_range($page) {
return min(max($page, 0), count($this->pagelayout) - 1);
}
// Simple getters ==========================================================
public function get_quiz() {
return $this->quizobj->get_quiz();
}
public function get_quizobj() {
return $this->quizobj;
}
/** @return int the course id. */
public function get_courseid() {
return $this->quizobj->get_courseid();
}
/** @return int the course id. */
public function get_course() {
return $this->quizobj->get_course();
}
/** @return int the quiz id. */
public function get_quizid() {
return $this->quizobj->get_quizid();
}
/** @return string the name of this quiz. */
public function get_quiz_name() {
return $this->quizobj->get_quiz_name();
}
/** @return int the quiz navigation method. */
public function get_navigation_method() {
return $this->quizobj->get_navigation_method();
}
/** @return object the course_module object. */
public function get_cm() {
return $this->quizobj->get_cm();
}
/** @return object the course_module object. */
public function get_cmid() {
return $this->quizobj->get_cmid();
}
/**
* @return bool wether the current user is someone who previews the quiz,
* rather than attempting it.
*/
public function is_preview_user() {
return $this->quizobj->is_preview_user();
}
/** @return int the number of attempts allowed at this quiz (0 = infinite). */
public function get_num_attempts_allowed() {
return $this->quizobj->get_num_attempts_allowed();
}
/** @return int number fo pages in this quiz. */
public function get_num_pages() {
return count($this->pagelayout);
}
/**
* @param int $timenow the current time as a unix timestamp.
* @return quiz_access_manager and instance of the quiz_access_manager class
* for this quiz at this time.
*/
public function get_access_manager($timenow) {
return $this->quizobj->get_access_manager($timenow);
}
/** @return int the attempt id. */
public function get_attemptid() {
return $this->attempt->id;
}
/** @return int the attempt unique id. */
public function get_uniqueid() {
return $this->attempt->uniqueid;
}
/** @return object the row from the quiz_attempts table. */
public function get_attempt() {
return $this->attempt;
}
/** @return int the number of this attemp (is it this user's first, second, ... attempt). */
public function get_attempt_number() {
return $this->attempt->attempt;
}
/** @return string one of the quiz_attempt::IN_PROGRESS, FINISHED, OVERDUE or ABANDONED constants. */
public function get_state() {
return $this->attempt->state;
}
/** @return int the id of the user this attempt belongs to. */
public function get_userid() {
return $this->attempt->userid;
}
/** @return int the current page of the attempt. */
public function get_currentpage() {
return $this->attempt->currentpage;
}
public function get_sum_marks() {
return $this->attempt->sumgrades;
}
/**
* @return bool whether this attempt has been finished (true) or is still
* in progress (false). Be warned that this is not just state == self::FINISHED,
* it also includes self::ABANDONED.
*/
public function is_finished() {
return $this->attempt->state == self::FINISHED || $this->attempt->state == self::ABANDONED;
}
/** @return bool whether this attempt is a preview attempt. */
public function is_preview() {
return $this->attempt->preview;
}
/**
* Is this someone dealing with their own attempt or preview?
*
* @return bool true => own attempt/preview. false => reviewing someone elses.
*/
public function is_own_attempt() {
global $USER;
return $this->attempt->userid == $USER->id;
}
/**
* @return bool whether this attempt is a preview belonging to the current user.
*/
public function is_own_preview() {
global $USER;
return $this->is_own_attempt() &&
$this->is_preview_user() && $this->attempt->preview;
}
/**
* Is the current user allowed to review this attempt. This applies when
* {@link is_own_attempt()} returns false.
* @return bool whether the review should be allowed.
*/
public function is_review_allowed() {
if (!$this->has_capability('mod/quiz:viewreports')) {
return false;
}
$cm = $this->get_cm();
if ($this->has_capability('moodle/site:accessallgroups') ||
groups_get_activity_groupmode($cm) != SEPARATEGROUPS) {
return true;
}
// Check the users have at least one group in common.
$teachersgroups = groups_get_activity_allowed_groups($cm);
$studentsgroups = groups_get_all_groups(
$cm->course, $this->attempt->userid, $cm->groupingid);
return $teachersgroups && $studentsgroups &&
array_intersect(array_keys($teachersgroups), array_keys($studentsgroups));
}
/**
* Has the student, in this attempt, engaged with the quiz in a non-trivial way?
* That is, is there any question worth a non-zero number of marks, where
* the student has made some response that we have saved?
* @return bool true if we have saved a response for at least one graded question.
*/
public function has_response_to_at_least_one_graded_question() {
foreach ($this->quba->get_attempt_iterator() as $qa) {
if ($qa->get_max_mark() == 0) {
continue;
}
if ($qa->get_num_steps() > 1) {
return true;
}
}
return false;
}
/**
* Get extra summary information about this attempt.
*
* Some behaviours may be able to provide interesting summary information
* about the attempt as a whole, and this method provides access to that data.
* To see how this works, try setting a quiz to one of the CBM behaviours,
* and then look at the extra information displayed at the top of the quiz
* review page once you have sumitted an attempt.
*
* In the return value, the array keys are identifiers of the form
* qbehaviour_behaviourname_meaningfullkey. For qbehaviour_deferredcbm_highsummary.
* The values are arrays with two items, title and content. Each of these
* will be either a string, or a renderable.
*
* @param question_display_options $options the display options for this quiz attempt at this time.
* @return array as described above.
*/
public function get_additional_summary_data(question_display_options $options) {
return $this->quba->get_summary_information($options);
}
/**
* Get the overall feedback corresponding to a particular mark.
* @param $grade a particular grade.
*/
public function get_overall_feedback($grade) {
return quiz_feedback_for_grade($grade, $this->get_quiz(),
$this->quizobj->get_context());
}
/**
* Wrapper round the has_capability funciton that automatically passes in the quiz context.
*/
public function has_capability($capability, $userid = null, $doanything = true) {
return $this->quizobj->has_capability($capability, $userid, $doanything);
}
/**
* Wrapper round the require_capability funciton that automatically passes in the quiz context.
*/
public function require_capability($capability, $userid = null, $doanything = true) {
return $this->quizobj->require_capability($capability, $userid, $doanything);
}
/**
* Check the appropriate capability to see whether this user may review their own attempt.
* If not, prints an error.
*/
public function check_review_capability() {
if ($this->get_attempt_state() == mod_quiz_display_options::IMMEDIATELY_AFTER) {
$capability = 'mod/quiz:attempt';
} else {
$capability = 'mod/quiz:reviewmyattempts';
}
// These next tests are in a slighly funny order. The point is that the
// common and most performance-critical case is students attempting a quiz
// so we want to check that permisison first.
if ($this->has_capability($capability)) {
// User has the permission that lets you do the quiz as a student. Fine.
return;
}
if ($this->has_capability('mod/quiz:viewreports') ||
$this->has_capability('mod/quiz:preview')) {
// User has the permission that lets teachers review. Fine.
return;
}
// They should not be here. Trigger the standard no-permission error
// but using the name of the student capability.
// We know this will fail. We just want the stadard exception thown.
$this->require_capability($capability);
}
/**
* Checks whether a user may navigate to a particular slot
*/
public function can_navigate_to($slot) {
switch ($this->get_navigation_method()) {
case QUIZ_NAVMETHOD_FREE:
return true;
break;
case QUIZ_NAVMETHOD_SEQ:
return false;
break;
}
return true;
}
/**
* @return int one of the mod_quiz_display_options::DURING,
* IMMEDIATELY_AFTER, LATER_WHILE_OPEN or AFTER_CLOSE constants.
*/
public function get_attempt_state() {
return quiz_attempt_state($this->get_quiz(), $this->attempt);
}
/**
* Wrapper that the correct mod_quiz_display_options for this quiz at the
* moment.
*
* @return question_display_options the render options for this user on this attempt.
*/
public function get_display_options($reviewing) {