Dani Palou
806 lines
29 KiB
PHP
806 lines
29 KiB
PHP
<?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/>.
|
|
|
|
/**
|
|
* mod_lesson data generator.
|
|
*
|
|
* @package mod_lesson
|
|
* @category test
|
|
* @copyright 2013 Marina Glancy
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
require_once($CFG->dirroot.'/mod/lesson/locallib.php');
|
|
|
|
/**
|
|
* mod_lesson data generator class.
|
|
*
|
|
* @package mod_lesson
|
|
* @category test
|
|
* @copyright 2013 Marina Glancy
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class mod_lesson_generator extends testing_module_generator {
|
|
|
|
/**
|
|
* @var int keep track of how many pages have been created.
|
|
*/
|
|
protected $pagecount = 0;
|
|
|
|
/**
|
|
* @var array list of candidate pages to be created when all answers have been added.
|
|
*/
|
|
protected $candidatepages = [];
|
|
|
|
/**
|
|
* @var array map of readable jumpto to integer value.
|
|
*/
|
|
protected $jumptomap = [
|
|
'This page' => LESSON_THISPAGE,
|
|
'Next page' => LESSON_NEXTPAGE,
|
|
'Previous page' => LESSON_PREVIOUSPAGE,
|
|
'End of lesson' => LESSON_EOL,
|
|
'Unseen question within a content page' => LESSON_UNSEENBRANCHPAGE,
|
|
'Random question within a content page' => LESSON_RANDOMPAGE,
|
|
'Random content page' => LESSON_RANDOMBRANCH,
|
|
'Unseen question within a cluster' => LESSON_CLUSTERJUMP,
|
|
];
|
|
|
|
/**
|
|
* To be called from data reset code only,
|
|
* do not use in tests.
|
|
* @return void
|
|
*/
|
|
public function reset() {
|
|
$this->pagecount = 0;
|
|
$this->candidatepages = [];
|
|
parent::reset();
|
|
}
|
|
|
|
/**
|
|
* Creates a lesson instance for testing purposes.
|
|
*
|
|
* @param null|array|stdClass $record data for module being generated.
|
|
* @param null|array $options general options for course module.
|
|
* @return stdClass record from module-defined table with additional field cmid (corresponding id in course_modules table)
|
|
*/
|
|
public function create_instance($record = null, array $options = null) {
|
|
global $CFG;
|
|
|
|
// Add default values for lesson.
|
|
$lessonconfig = get_config('mod_lesson');
|
|
$record = (array)$record + array(
|
|
'progressbar' => $lessonconfig->progressbar,
|
|
'ongoing' => $lessonconfig->ongoing,
|
|
'displayleft' => $lessonconfig->displayleftmenu,
|
|
'displayleftif' => $lessonconfig->displayleftif,
|
|
'slideshow' => $lessonconfig->slideshow,
|
|
'maxanswers' => $lessonconfig->maxanswers,
|
|
'feedback' => $lessonconfig->defaultfeedback,
|
|
'activitylink' => 0,
|
|
'available' => 0,
|
|
'deadline' => 0,
|
|
'usepassword' => 0,
|
|
'password' => '',
|
|
'dependency' => 0,
|
|
'timespent' => 0,
|
|
'completed' => 0,
|
|
'gradebetterthan' => 0,
|
|
'modattempts' => $lessonconfig->modattempts,
|
|
'review' => $lessonconfig->displayreview,
|
|
'maxattempts' => $lessonconfig->maximumnumberofattempts,
|
|
'nextpagedefault' => $lessonconfig->defaultnextpage,
|
|
'maxpages' => $lessonconfig->numberofpagestoshow,
|
|
'practice' => $lessonconfig->practice,
|
|
'custom' => $lessonconfig->customscoring,
|
|
'retake' => $lessonconfig->retakesallowed,
|
|
'usemaxgrade' => $lessonconfig->handlingofretakes,
|
|
'minquestions' => $lessonconfig->minimumnumberofquestions,
|
|
'grade' => 100,
|
|
);
|
|
if (!isset($record['mediafile'])) {
|
|
require_once($CFG->libdir.'/filelib.php');
|
|
$record['mediafile'] = file_get_unused_draft_itemid();
|
|
}
|
|
|
|
return parent::create_instance($record, (array)$options);
|
|
}
|
|
|
|
/**
|
|
* Creates a page for testing purposes. The page will be created when answers are added.
|
|
*
|
|
* @param null|array|stdClass $record data for page being generated.
|
|
* @param null|array $options general options.
|
|
*/
|
|
public function create_page($record = null, array $options = null) {
|
|
$record = (array) $record;
|
|
|
|
// Pages require answers to work. Add it as a candidate page to be created once answers have been added.
|
|
$record['answer_editor'] = [];
|
|
$record['response_editor'] = [];
|
|
$record['jumpto'] = [];
|
|
$record['score'] = [];
|
|
|
|
if (!isset($record['previouspage']) || $record['previouspage'] === '') {
|
|
// Previous page not set, set it to the last candidate page (if any).
|
|
$record['previouspage'] = empty($this->candidatepages) ? '0' : end($this->candidatepages)['title'];
|
|
}
|
|
|
|
$this->candidatepages[] = $record;
|
|
}
|
|
|
|
/**
|
|
* Creates a page and its answers for testing purposes.
|
|
*
|
|
* @param array $record data for page being generated.
|
|
* @return stdClass created page, null if couldn't be created because it has a jump to a page that doesn't exist.
|
|
* @throws coding_exception
|
|
*/
|
|
private function perform_create_page(array $record): ?stdClass {
|
|
global $DB;
|
|
|
|
$lesson = $DB->get_record('lesson', ['id' => $record['lessonid']], '*', MUST_EXIST);
|
|
$cm = get_coursemodule_from_instance('lesson', $lesson->id);
|
|
$lesson->cmid = $cm->id;
|
|
$qtype = $record['qtype'];
|
|
|
|
unset($record['qtype']);
|
|
unset($record['lessonid']);
|
|
|
|
if (isset($record['content'])) {
|
|
$record['contents_editor'] = [
|
|
'text' => $record['content'],
|
|
'format' => FORMAT_MOODLE,
|
|
'itemid' => 0,
|
|
];
|
|
unset($record['content']);
|
|
}
|
|
|
|
$record['pageid'] = $this->get_previouspage_id($lesson->id, $record['previouspage']);
|
|
unset($record['previouspage']);
|
|
|
|
try {
|
|
$record['jumpto'] = $this->convert_page_jumpto($lesson->id, $record['jumpto']);
|
|
} catch (coding_exception $e) {
|
|
// This page has a jump to a page that hasn't been created yet.
|
|
return null;
|
|
}
|
|
|
|
switch ($qtype) {
|
|
case 'content':
|
|
case 'cluster':
|
|
case 'endofcluster':
|
|
case 'endofbranch':
|
|
$funcname = "create_{$qtype}";
|
|
break;
|
|
default:
|
|
$funcname = "create_question_{$qtype}";
|
|
}
|
|
|
|
if (!method_exists($this, $funcname)) {
|
|
throw new coding_exception('The page '.$record['title']." has an invalid qtype: $qtype");
|
|
}
|
|
|
|
return $this->{$funcname}($lesson, $record);
|
|
}
|
|
|
|
/**
|
|
* Creates a content page for testing purposes.
|
|
*
|
|
* @param stdClass $lesson instance where to create the page.
|
|
* @param array|stdClass $record data for page being generated.
|
|
* @return stdClass page record.
|
|
*/
|
|
public function create_content($lesson, $record = array()) {
|
|
global $DB, $CFG;
|
|
$now = time();
|
|
$this->pagecount++;
|
|
$record = (array)$record + array(
|
|
'lessonid' => $lesson->id,
|
|
'title' => 'Lesson page '.$this->pagecount,
|
|
'timecreated' => $now,
|
|
'qtype' => 20, // LESSON_PAGE_BRANCHTABLE
|
|
'pageid' => 0, // By default insert in the beginning.
|
|
);
|
|
if (!isset($record['contents_editor'])) {
|
|
$record['contents_editor'] = array(
|
|
'text' => 'Contents of lesson page '.$this->pagecount,
|
|
'format' => FORMAT_MOODLE,
|
|
'itemid' => 0,
|
|
);
|
|
}
|
|
$context = context_module::instance($lesson->cmid);
|
|
$page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
|
|
return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Create True/false question pages.
|
|
* @param object $lesson
|
|
* @param array $record
|
|
* @return stdClass page record.
|
|
*/
|
|
public function create_question_truefalse($lesson, $record = array()) {
|
|
global $DB, $CFG;
|
|
$now = time();
|
|
$this->pagecount++;
|
|
$record = (array)$record + array(
|
|
'lessonid' => $lesson->id,
|
|
'title' => 'Lesson TF question '.$this->pagecount,
|
|
'timecreated' => $now,
|
|
'qtype' => 2, // LESSON_PAGE_TRUEFALSE.
|
|
'pageid' => 0, // By default insert in the beginning.
|
|
);
|
|
if (!isset($record['contents_editor'])) {
|
|
$record['contents_editor'] = array(
|
|
'text' => 'The answer is TRUE '.$this->pagecount,
|
|
'format' => FORMAT_HTML,
|
|
'itemid' => 0
|
|
);
|
|
}
|
|
|
|
// First Answer (TRUE).
|
|
if (!isset($record['answer_editor'][0])) {
|
|
$record['answer_editor'][0] = array(
|
|
'text' => 'TRUE answer for '.$this->pagecount,
|
|
'format' => FORMAT_HTML
|
|
);
|
|
}
|
|
if (!isset($record['jumpto'][0])) {
|
|
$record['jumpto'][0] = LESSON_NEXTPAGE;
|
|
}
|
|
|
|
// Second Answer (FALSE).
|
|
if (!isset($record['answer_editor'][1])) {
|
|
$record['answer_editor'][1] = array(
|
|
'text' => 'FALSE answer for '.$this->pagecount,
|
|
'format' => FORMAT_HTML
|
|
);
|
|
}
|
|
if (!isset($record['jumpto'][1])) {
|
|
$record['jumpto'][1] = LESSON_THISPAGE;
|
|
}
|
|
|
|
$context = context_module::instance($lesson->cmid);
|
|
$page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
|
|
return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Create multichoice question pages.
|
|
* @param object $lesson
|
|
* @param array $record
|
|
* @return stdClass page record.
|
|
*/
|
|
public function create_question_multichoice($lesson, $record = array()) {
|
|
global $DB, $CFG;
|
|
$now = time();
|
|
$this->pagecount++;
|
|
$record = (array)$record + array(
|
|
'lessonid' => $lesson->id,
|
|
'title' => 'Lesson multichoice question '.$this->pagecount,
|
|
'timecreated' => $now,
|
|
'qtype' => 3, // LESSON_PAGE_MULTICHOICE.
|
|
'pageid' => 0, // By default insert in the beginning.
|
|
);
|
|
if (!isset($record['contents_editor'])) {
|
|
$record['contents_editor'] = array(
|
|
'text' => 'Pick the correct answer '.$this->pagecount,
|
|
'format' => FORMAT_HTML,
|
|
'itemid' => 0
|
|
);
|
|
}
|
|
|
|
// First Answer (correct).
|
|
if (!isset($record['answer_editor'][0])) {
|
|
$record['answer_editor'][0] = array(
|
|
'text' => 'correct answer for '.$this->pagecount,
|
|
'format' => FORMAT_HTML
|
|
);
|
|
}
|
|
if (!isset($record['jumpto'][0])) {
|
|
$record['jumpto'][0] = LESSON_NEXTPAGE;
|
|
}
|
|
|
|
// Second Answer (incorrect).
|
|
if (!isset($record['answer_editor'][1])) {
|
|
$record['answer_editor'][1] = array(
|
|
'text' => 'correct answer for '.$this->pagecount,
|
|
'format' => FORMAT_HTML
|
|
);
|
|
}
|
|
if (!isset($record['jumpto'][1])) {
|
|
$record['jumpto'][1] = LESSON_THISPAGE;
|
|
}
|
|
|
|
$context = context_module::instance($lesson->cmid);
|
|
$page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
|
|
return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Create essay question pages.
|
|
* @param object $lesson
|
|
* @param array $record
|
|
* @return stdClass page record.
|
|
*/
|
|
public function create_question_essay($lesson, $record = array()) {
|
|
global $DB, $CFG;
|
|
$now = time();
|
|
$this->pagecount++;
|
|
$record = (array)$record + array(
|
|
'lessonid' => $lesson->id,
|
|
'title' => 'Lesson Essay question '.$this->pagecount,
|
|
'timecreated' => $now,
|
|
'qtype' => 10, // LESSON_PAGE_ESSAY.
|
|
'pageid' => 0, // By default insert in the beginning.
|
|
);
|
|
if (!isset($record['contents_editor'])) {
|
|
$record['contents_editor'] = array(
|
|
'text' => 'Write an Essay '.$this->pagecount,
|
|
'format' => FORMAT_HTML,
|
|
'itemid' => 0
|
|
);
|
|
}
|
|
|
|
// Essays have an answer of NULL.
|
|
if (!isset($record['answer_editor'][0])) {
|
|
$record['answer_editor'][0] = array(
|
|
'text' => null,
|
|
'format' => FORMAT_MOODLE
|
|
);
|
|
}
|
|
if (!isset($record['jumpto'][0])) {
|
|
$record['jumpto'][0] = LESSON_NEXTPAGE;
|
|
}
|
|
|
|
$context = context_module::instance($lesson->cmid);
|
|
$page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
|
|
return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Create matching question pages.
|
|
* @param object $lesson
|
|
* @param array $record
|
|
* @return stdClass page record.
|
|
*/
|
|
public function create_question_matching($lesson, $record = array()) {
|
|
global $DB, $CFG;
|
|
$now = time();
|
|
$this->pagecount++;
|
|
$record = (array)$record + array(
|
|
'lessonid' => $lesson->id,
|
|
'title' => 'Lesson Matching question '.$this->pagecount,
|
|
'timecreated' => $now,
|
|
'qtype' => 5, // LESSON_PAGE_MATCHING.
|
|
'pageid' => 0, // By default insert in the beginning.
|
|
);
|
|
if (!isset($record['contents_editor'])) {
|
|
$record['contents_editor'] = array(
|
|
'text' => 'Match the values '.$this->pagecount,
|
|
'format' => FORMAT_HTML,
|
|
'itemid' => 0
|
|
);
|
|
}
|
|
// Feedback for correct result.
|
|
if (!isset($record['answer_editor'][0])) {
|
|
$record['answer_editor'][0] = array(
|
|
'text' => '',
|
|
'format' => FORMAT_HTML
|
|
);
|
|
}
|
|
// Feedback for wrong result.
|
|
if (!isset($record['answer_editor'][1])) {
|
|
$record['answer_editor'][1] = array(
|
|
'text' => '',
|
|
'format' => FORMAT_HTML
|
|
);
|
|
}
|
|
// First answer value.
|
|
if (!isset($record['answer_editor'][2])) {
|
|
$record['answer_editor'][2] = array(
|
|
'text' => 'Match value 1',
|
|
'format' => FORMAT_HTML
|
|
);
|
|
}
|
|
// First response value.
|
|
if (!isset($record['response_editor'][2])) {
|
|
$record['response_editor'][2] = 'Match answer 1';
|
|
}
|
|
// Second Matching value.
|
|
if (!isset($record['answer_editor'][3])) {
|
|
$record['answer_editor'][3] = array(
|
|
'text' => 'Match value 2',
|
|
'format' => FORMAT_HTML
|
|
);
|
|
}
|
|
// Second Matching answer.
|
|
if (!isset($record['response_editor'][3])) {
|
|
$record['response_editor'][3] = 'Match answer 2';
|
|
}
|
|
|
|
// Jump Values.
|
|
if (!isset($record['jumpto'][0])) {
|
|
$record['jumpto'][0] = LESSON_NEXTPAGE;
|
|
}
|
|
if (!isset($record['jumpto'][1])) {
|
|
$record['jumpto'][1] = LESSON_THISPAGE;
|
|
}
|
|
|
|
// Mark the correct values.
|
|
if (!isset($record['score'][0])) {
|
|
$record['score'][0] = 1;
|
|
}
|
|
$context = context_module::instance($lesson->cmid);
|
|
$page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
|
|
return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Create shortanswer question pages.
|
|
* @param object $lesson
|
|
* @param array $record
|
|
* @return stdClass page record.
|
|
*/
|
|
public function create_question_shortanswer($lesson, $record = array()) {
|
|
global $DB, $CFG;
|
|
$now = time();
|
|
$this->pagecount++;
|
|
$record = (array)$record + array(
|
|
'lessonid' => $lesson->id,
|
|
'title' => 'Lesson Shortanswer question '.$this->pagecount,
|
|
'timecreated' => $now,
|
|
'qtype' => 1, // LESSON_PAGE_SHORTANSWER.
|
|
'pageid' => 0, // By default insert in the beginning.
|
|
);
|
|
if (!isset($record['contents_editor'])) {
|
|
$record['contents_editor'] = array(
|
|
'text' => 'Fill in the blank '.$this->pagecount,
|
|
'format' => FORMAT_HTML,
|
|
'itemid' => 0
|
|
);
|
|
}
|
|
|
|
// First Answer (correct).
|
|
if (!isset($record['answer_editor'][0])) {
|
|
$record['answer_editor'][0] = array(
|
|
'text' => 'answer'.$this->pagecount,
|
|
'format' => FORMAT_MOODLE
|
|
);
|
|
}
|
|
if (!isset($record['jumpto'][0])) {
|
|
$record['jumpto'][0] = LESSON_NEXTPAGE;
|
|
}
|
|
|
|
$context = context_module::instance($lesson->cmid);
|
|
$page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
|
|
return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Create shortanswer question pages.
|
|
* @param object $lesson
|
|
* @param array $record
|
|
* @return stdClass page record.
|
|
*/
|
|
public function create_question_numeric($lesson, $record = array()) {
|
|
global $DB, $CFG;
|
|
$now = time();
|
|
$this->pagecount++;
|
|
$record = (array)$record + array(
|
|
'lessonid' => $lesson->id,
|
|
'title' => 'Lesson numerical question '.$this->pagecount,
|
|
'timecreated' => $now,
|
|
'qtype' => 8, // LESSON_PAGE_NUMERICAL.
|
|
'pageid' => 0, // By default insert in the beginning.
|
|
);
|
|
if (!isset($record['contents_editor'])) {
|
|
$record['contents_editor'] = array(
|
|
'text' => 'Numerical question '.$this->pagecount,
|
|
'format' => FORMAT_HTML,
|
|
'itemid' => 0
|
|
);
|
|
}
|
|
|
|
// First Answer (correct).
|
|
if (!isset($record['answer_editor'][0])) {
|
|
$record['answer_editor'][0] = array(
|
|
'text' => $this->pagecount,
|
|
'format' => FORMAT_MOODLE
|
|
);
|
|
}
|
|
if (!isset($record['jumpto'][0])) {
|
|
$record['jumpto'][0] = LESSON_NEXTPAGE;
|
|
}
|
|
|
|
$context = context_module::instance($lesson->cmid);
|
|
$page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
|
|
return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Creates a cluster page for testing purposes.
|
|
*
|
|
* @param stdClass $lesson instance where to create the page.
|
|
* @param array $record data for page being generated.
|
|
* @return stdClass page record.
|
|
*/
|
|
public function create_cluster(stdClass $lesson, array $record = []): stdClass {
|
|
global $DB, $CFG;
|
|
$now = time();
|
|
$this->pagecount++;
|
|
$record = $record + [
|
|
'lessonid' => $lesson->id,
|
|
'title' => 'Cluster '.$this->pagecount,
|
|
'timecreated' => $now,
|
|
'qtype' => 30, // LESSON_PAGE_CLUSTER.
|
|
'pageid' => 0, // By default insert in the beginning.
|
|
];
|
|
if (!isset($record['contents_editor'])) {
|
|
$record['contents_editor'] = [
|
|
'text' => 'Cluster '.$this->pagecount,
|
|
'format' => FORMAT_MOODLE,
|
|
'itemid' => 0,
|
|
];
|
|
}
|
|
$context = context_module::instance($lesson->cmid);
|
|
$page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
|
|
return $DB->get_record('lesson_pages', ['id' => $page->id], '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Creates a end of cluster page for testing purposes.
|
|
*
|
|
* @param stdClass $lesson instance where to create the page.
|
|
* @param array $record data for page being generated.
|
|
* @return stdClass page record.
|
|
*/
|
|
public function create_endofcluster(stdClass $lesson, array $record = []): stdClass {
|
|
global $DB, $CFG;
|
|
$now = time();
|
|
$this->pagecount++;
|
|
$record = $record + [
|
|
'lessonid' => $lesson->id,
|
|
'title' => 'End of cluster '.$this->pagecount,
|
|
'timecreated' => $now,
|
|
'qtype' => 31, // LESSON_PAGE_ENDOFCLUSTER.
|
|
'pageid' => 0, // By default insert in the beginning.
|
|
];
|
|
if (!isset($record['contents_editor'])) {
|
|
$record['contents_editor'] = [
|
|
'text' => 'End of cluster '.$this->pagecount,
|
|
'format' => FORMAT_MOODLE,
|
|
'itemid' => 0,
|
|
];
|
|
}
|
|
$context = context_module::instance($lesson->cmid);
|
|
$page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
|
|
return $DB->get_record('lesson_pages', ['id' => $page->id], '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Creates a end of branch page for testing purposes.
|
|
*
|
|
* @param stdClass $lesson instance where to create the page.
|
|
* @param array $record data for page being generated.
|
|
* @return stdClass page record.
|
|
*/
|
|
public function create_endofbranch(stdClass $lesson, array $record = []): stdClass {
|
|
global $DB, $CFG;
|
|
$now = time();
|
|
$this->pagecount++;
|
|
$record = $record + [
|
|
'lessonid' => $lesson->id,
|
|
'title' => 'End of branch '.$this->pagecount,
|
|
'timecreated' => $now,
|
|
'qtype' => 21, // LESSON_PAGE_ENDOFBRANCH.
|
|
'pageid' => 0, // By default insert in the beginning.
|
|
];
|
|
if (!isset($record['contents_editor'])) {
|
|
$record['contents_editor'] = [
|
|
'text' => 'End of branch '.$this->pagecount,
|
|
'format' => FORMAT_MOODLE,
|
|
'itemid' => 0,
|
|
];
|
|
}
|
|
$context = context_module::instance($lesson->cmid);
|
|
$page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
|
|
return $DB->get_record('lesson_pages', ['id' => $page->id], '*', MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Create a lesson override (either user or group).
|
|
*
|
|
* @param array $data must specify lessonid, and one of userid or groupid.
|
|
* @throws coding_exception
|
|
*/
|
|
public function create_override(array $data): void {
|
|
global $DB;
|
|
|
|
if (!isset($data['lessonid'])) {
|
|
throw new coding_exception('Must specify lessonid when creating a lesson override.');
|
|
}
|
|
|
|
if (!isset($data['userid']) && !isset($data['groupid'])) {
|
|
throw new coding_exception('Must specify one of userid or groupid when creating a lesson override.');
|
|
}
|
|
|
|
if (isset($data['userid']) && isset($data['groupid'])) {
|
|
throw new coding_exception('Cannot specify both userid and groupid when creating a lesson override.');
|
|
}
|
|
|
|
$DB->insert_record('lesson_overrides', (object) $data);
|
|
}
|
|
|
|
/**
|
|
* Creates an answer in a page for testing purposes.
|
|
*
|
|
* @param null|array|stdClass $record data for module being generated.
|
|
* @param null|array $options general options.
|
|
* @throws coding_exception
|
|
*/
|
|
public function create_answer($record = null, array $options = null) {
|
|
$record = (array) $record;
|
|
|
|
$candidatepage = null;
|
|
$pagetitle = $record['page'];
|
|
$found = false;
|
|
foreach ($this->candidatepages as &$candidatepage) {
|
|
if ($candidatepage['title'] === $pagetitle) {
|
|
$found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!$found) {
|
|
throw new coding_exception("Page '$pagetitle' not found in candidate pages. Please make sure the page exists "
|
|
. 'and all answers are in the same table.');
|
|
}
|
|
|
|
if (isset($record['answer'])) {
|
|
$candidatepage['answer_editor'][] = [
|
|
'text' => $record['answer'],
|
|
'format' => FORMAT_HTML,
|
|
];
|
|
} else {
|
|
$candidatepage['answer_editor'][] = null;
|
|
}
|
|
|
|
if (isset($record['response'])) {
|
|
$candidatepage['response_editor'][] = [
|
|
'text' => $record['response'],
|
|
'format' => FORMAT_HTML,
|
|
];
|
|
} else {
|
|
$candidatepage['response_editor'][] = null;
|
|
}
|
|
|
|
$candidatepage['jumpto'][] = $record['jumpto'] ?? LESSON_THISPAGE;
|
|
$candidatepage['score'][] = $record['score'] ?? 0;
|
|
}
|
|
|
|
/**
|
|
* All answers in a table have been generated, create the pages.
|
|
*/
|
|
public function finish_generate_answer() {
|
|
$this->create_candidate_pages();
|
|
}
|
|
|
|
/**
|
|
* Create candidate pages.
|
|
*
|
|
* @throws coding_exception
|
|
*/
|
|
protected function create_candidate_pages(): void {
|
|
// For performance reasons it would be better to use a topological sort algorithm. But since test cases shouldn't have
|
|
// a lot of paged and complex jumps it was implemented using a simpler approach.
|
|
$consecutiveblocked = 0;
|
|
|
|
while (count($this->candidatepages) > 0) {
|
|
$page = array_shift($this->candidatepages);
|
|
$id = $this->perform_create_page($page);
|
|
|
|
if ($id === null) {
|
|
// Page cannot be created yet because of jumpto. Move it to the end of list.
|
|
$consecutiveblocked++;
|
|
$this->candidatepages[] = $page;
|
|
|
|
if ($consecutiveblocked === count($this->candidatepages)) {
|
|
throw new coding_exception('There is a circular dependency in pages jumps.');
|
|
}
|
|
} else {
|
|
$consecutiveblocked = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculate the previous page id.
|
|
* If no page title is supplied, use the last page created in the lesson (0 if no pages).
|
|
* If page title is supplied, search it in DB and the list of candidate pages.
|
|
*
|
|
* @param int $lessonid the lesson id.
|
|
* @param string $pagetitle the page title, for example 'Test page'. '0' if no previous page.
|
|
* @return int corresponding id. 0 if no previous page.
|
|
* @throws coding_exception
|
|
*/
|
|
protected function get_previouspage_id(int $lessonid, string $pagetitle): int {
|
|
global $DB;
|
|
|
|
if (is_numeric($pagetitle) && intval($pagetitle) === 0) {
|
|
return 0;
|
|
}
|
|
|
|
$pages = $DB->get_records('lesson_pages', ['lessonid' => $lessonid, 'title' => $pagetitle], 'id ASC', 'id, title');
|
|
|
|
if (count($pages) > 1) {
|
|
throw new coding_exception("More than one page with '$pagetitle' found");
|
|
} else if (!empty($pages)) {
|
|
return current($pages)->id;
|
|
}
|
|
|
|
// Page doesn't exist, search if it's a candidate page. If it is, use its previous page instead.
|
|
foreach ($this->candidatepages as $candidatepage) {
|
|
if ($candidatepage['title'] === $pagetitle) {
|
|
return $this->get_previouspage_id($lessonid, $candidatepage['previouspage']);
|
|
}
|
|
}
|
|
|
|
throw new coding_exception("Page '$pagetitle' not found");
|
|
}
|
|
|
|
/**
|
|
* Convert the jumpto using a string to an integer value.
|
|
* The jumpto can contain a page name or one of our predefined values.
|
|
*
|
|
* @param int $lessonid the lesson id.
|
|
* @param array|null $jumptolist list of jumpto to treat.
|
|
* @return array|null list of jumpto already treated.
|
|
* @throws coding_exception
|
|
*/
|
|
protected function convert_page_jumpto(int $lessonid, ?array $jumptolist): ?array {
|
|
global $DB;
|
|
|
|
if (empty($jumptolist)) {
|
|
return $jumptolist;
|
|
}
|
|
|
|
foreach ($jumptolist as $i => $jumpto) {
|
|
if (empty($jumpto) || is_numeric($jumpto)) {
|
|
continue;
|
|
}
|
|
|
|
if (isset($this->jumptomap[$jumpto])) {
|
|
$jumptolist[$i] = $this->jumptomap[$jumpto];
|
|
|
|
continue;
|
|
}
|
|
|
|
$page = $DB->get_record('lesson_pages', ['lessonid' => $lessonid, 'title' => $jumpto], 'id');
|
|
if ($page === false) {
|
|
throw new coding_exception("Jump '$jumpto' not found in pages.");
|
|
}
|
|
|
|
$jumptolist[$i] = $page->id;
|
|
}
|
|
|
|
return $jumptolist;
|
|
}
|
|
}
|