Proyectos de Subversion Moodle

<?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/>.

/**

 * Defines the quiz module ettings form.

 *

 * @package    mod_quiz

 * @copyright  2006 Jamie Pratt

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

defined('MOODLE_INTERNAL') || die();

require_once($CFG->dirroot . '/course/moodleform_mod.php');

require_once($CFG->dirroot . '/mod/quiz/locallib.php');

use mod_quiz\access_manager;

use mod_quiz\question\display_options;

/**

 * Settings form for the quiz module.

 *

 * @copyright  2006 Jamie Pratt

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class mod_quiz_mod_form extends moodleform_mod {

    /** @var array options to be used with date_time_selector fields in the quiz. */

    public static $datefieldoptions = ['optional' => true];

    /** @var array caches the quiz overall feedback, for convenience. */

    protected $_feedbacks;

    /** @var array for convenience stores the list of types of review option. Initialised in the constructor. */

    protected static $reviewfields = [];

    /** @var int the max number of attempts allowed in any user or group override on this quiz. */

    protected $maxattemptsanyoverride = null;

    public function __construct($current, $section, $cm, $course) {

        self::$reviewfields = [

            'attempt'          => ['theattempt', 'quiz'],

            'correctness'      => ['whethercorrect', 'question'],

            'maxmarks'         => ['maxmarks', 'quiz'],

            'marks'            => ['marks', 'quiz'],

            'specificfeedback' => ['specificfeedback', 'question'],

            'generalfeedback'  => ['generalfeedback', 'question'],

            'rightanswer'      => ['rightanswer', 'question'],

            'overallfeedback'  => ['reviewoverallfeedback', 'quiz'],

        ];

        parent::__construct($current, $section, $cm, $course);

    }

    protected function definition() {

        global $CFG, $DB, $PAGE;

        $quizconfig = get_config('quiz');

        $mform = $this->_form;

        // -------------------------------------------------------------------------------

        $mform->addElement('header', 'general', get_string('general', 'form'));

        // Name.

        $mform->addElement('text', 'name', get_string('name'), ['size' => '64']);

        if (!empty($CFG->formatstringstriptags)) {

            $mform->setType('name', PARAM_TEXT);

        } else {

            $mform->setType('name', PARAM_CLEANHTML);

        }

        $mform->addRule('name', null, 'required', null, 'client');

        $mform->addRule('name', get_string('maximumchars', '', 255), 'maxlength', 255, 'client');

        // Introduction.

        $this->standard_intro_elements(get_string('introduction', 'quiz'));

        // -------------------------------------------------------------------------------

        $mform->addElement('header', 'timing', get_string('timing', 'quiz'));

        // Open and close dates.

        $mform->addElement('date_time_selector', 'timeopen', get_string('quizopen', 'quiz'),

                self::$datefieldoptions);

        $mform->addHelpButton('timeopen', 'quizopenclose', 'quiz');

        $mform->addElement('date_time_selector', 'timeclose', get_string('quizclose', 'quiz'),

                self::$datefieldoptions);

        // Time limit.

        $mform->addElement('duration', 'timelimit', get_string('timelimit', 'quiz'),

                ['optional' => true]);

        $mform->addHelpButton('timelimit', 'timelimit', 'quiz');

        // What to do with overdue attempts.

        $mform->addElement('select', 'overduehandling', get_string('overduehandling', 'quiz'),

                quiz_get_overdue_handling_options());

        $mform->addHelpButton('overduehandling', 'overduehandling', 'quiz');

        // TODO Formslib does OR logic on disableif, and we need AND logic here.

        // $mform->disabledIf('overduehandling', 'timelimit', 'eq', 0);

        // $mform->disabledIf('overduehandling', 'timeclose', 'eq', 0);

        // Grace period time.

        $mform->addElement('duration', 'graceperiod', get_string('graceperiod', 'quiz'),

                ['optional' => true]);

        $mform->addHelpButton('graceperiod', 'graceperiod', 'quiz');

        $mform->hideIf('graceperiod', 'overduehandling', 'neq', 'graceperiod');

        // Pre-create attempts.

        // This is only shown if "Pre-create period" as been set at site level, and the quiz open time is enabled.

        $precreateperiod = get_config('quiz', 'precreateperiod');

        if (!empty($precreateperiod)) {

            $yesoption = get_string('precreateyes', 'quiz', $precreateperiod / HOURSECS);

            $precreateoptions = [

                1 => $yesoption,

            ];

            $mform->addElement(

                'select',

                'precreateattempts',

                get_string('precreateattempts', 'quiz'),

                $precreateoptions

            );

            $mform->hideIf('precreateattempts', 'timeopen[enabled]');

            $mform->addHelpButton('precreateattempts', 'precreateattempts', 'quiz');

        }

        // -------------------------------------------------------------------------------

        // Grade settings.

        $this->standard_grading_coursemodule_elements();

        $mform->removeElement('grade');

        if (property_exists($this->current, 'grade')) {

            $currentgrade = $this->current->grade;

        } else {

            $currentgrade = $quizconfig->maximumgrade;

        }

        $mform->addElement('hidden', 'grade', $currentgrade);

        $mform->setType('grade', PARAM_FLOAT);

        // Number of attempts.

        $attemptoptions = ['0' => get_string('unlimited')];

        for ($i = 1; $i <= QUIZ_MAX_ATTEMPT_OPTION; $i++) {

            $attemptoptions[$i] = $i;

        }

        $mform->addElement('select', 'attempts', get_string('attemptsallowed', 'quiz'),

                $attemptoptions);

        // Grading method.

        $mform->addElement('select', 'grademethod', get_string('grademethod', 'quiz'),

                quiz_get_grading_options());

        $mform->addHelpButton('grademethod', 'grademethod', 'quiz');

        if ($this->get_max_attempts_for_any_override() < 2) {

            $mform->hideIf('grademethod', 'attempts', 'eq', 1);

        }

        // -------------------------------------------------------------------------------

        $mform->addElement('header', 'layouthdr', get_string('layout', 'quiz'));

        $pagegroup = [];

        $pagegroup[] = $mform->createElement('select', 'questionsperpage',

                get_string('newpage', 'quiz'), quiz_questions_per_page_options(), ['id' => 'id_questionsperpage']);

        $mform->setDefault('questionsperpage', $quizconfig->questionsperpage);

        if (!empty($this->_cm) && !quiz_has_attempts($this->_cm->instance)) {

            $pagegroup[] = $mform->createElement('checkbox', 'repaginatenow', '',

                    get_string('repaginatenow', 'quiz'), ['id' => 'id_repaginatenow']);

        }

        $mform->addGroup($pagegroup, 'questionsperpagegrp',

                get_string('newpage', 'quiz'), null, false);

        $mform->addHelpButton('questionsperpagegrp', 'newpage', 'quiz');

        $mform->setAdvanced('questionsperpagegrp', $quizconfig->questionsperpage_adv);

        // Navigation method.

        $mform->addElement('select', 'navmethod', get_string('navmethod', 'quiz'),

                quiz_get_navigation_options());

        $mform->addHelpButton('navmethod', 'navmethod', 'quiz');

        // -------------------------------------------------------------------------------

        $mform->addElement('header', 'interactionhdr', get_string('questionbehaviour', 'quiz'));

        // Shuffle within questions.

        $mform->addElement('selectyesno', 'shuffleanswers', get_string('shufflewithin', 'quiz'));

        $mform->addHelpButton('shuffleanswers', 'shufflewithin', 'quiz');

        // How questions behave (question behaviour).

        if (!empty($this->current->preferredbehaviour)) {

            $currentbehaviour = $this->current->preferredbehaviour;

        } else {

            $currentbehaviour = '';

        }

        $behaviours = question_engine::get_behaviour_options($currentbehaviour);

        $mform->addElement('select', 'preferredbehaviour',

                get_string('howquestionsbehave', 'question'), $behaviours);

        $mform->addHelpButton('preferredbehaviour', 'howquestionsbehave', 'question');

        // Can redo completed questions.

        $redochoices = [0 => get_string('no'), 1 => get_string('canredoquestionsyes', 'quiz')];

        $mform->addElement('select', 'canredoquestions', get_string('canredoquestions', 'quiz'), $redochoices);

        $mform->addHelpButton('canredoquestions', 'canredoquestions', 'quiz');

        foreach ($behaviours as $behaviour => $notused) {

            if (!question_engine::can_questions_finish_during_the_attempt($behaviour)) {

                $mform->hideIf('canredoquestions', 'preferredbehaviour', 'eq', $behaviour);

            }

        }

        // Each attempt builds on last.

        $mform->addElement('selectyesno', 'attemptonlast',

                get_string('eachattemptbuildsonthelast', 'quiz'));

        $mform->addHelpButton('attemptonlast', 'eachattemptbuildsonthelast', 'quiz');

        if ($this->get_max_attempts_for_any_override() < 2) {

            $mform->hideIf('attemptonlast', 'attempts', 'eq', 1);

        }

        // -------------------------------------------------------------------------------

        $mform->addElement('header', 'reviewoptionshdr',

                get_string('reviewoptionsheading', 'quiz'));

        $mform->addHelpButton('reviewoptionshdr', 'reviewoptionsheading', 'quiz');

        // Review options.

        $this->add_review_options_group($mform, $quizconfig, 'during',

                display_options::DURING, true);

        $this->add_review_options_group($mform, $quizconfig, 'immediately',

                display_options::IMMEDIATELY_AFTER);

        $this->add_review_options_group($mform, $quizconfig, 'open',

                display_options::LATER_WHILE_OPEN);

        $this->add_review_options_group($mform, $quizconfig, 'closed',

                display_options::AFTER_CLOSE);

        foreach ($behaviours as $behaviour => $notused) {

            $unusedoptions = question_engine::get_behaviour_unused_display_options($behaviour);

            foreach ($unusedoptions as $unusedoption) {

                $mform->disabledIf($unusedoption . 'during', 'preferredbehaviour',

                        'eq', $behaviour);

            }

        }

        $mform->disabledIf('attemptduring', 'preferredbehaviour',

                'neq', 'wontmatch');

        $mform->disabledIf('overallfeedbackduring', 'preferredbehaviour',

                'neq', 'wontmatch');

        foreach (self::$reviewfields as $field => $notused) {

            $mform->disabledIf($field . 'closed', 'timeclose[enabled]');

        }

        // -------------------------------------------------------------------------------

        $mform->addElement('header', 'display', get_string('appearance'));

        // Show user picture.

        $mform->addElement('select', 'showuserpicture', get_string('showuserpicture', 'quiz'),

                quiz_get_user_image_options());

        $mform->addHelpButton('showuserpicture', 'showuserpicture', 'quiz');

        // Overall decimal points.

        $options = [];

        for ($i = 0; $i <= QUIZ_MAX_DECIMAL_OPTION; $i++) {

            $options[$i] = $i;

        }

        $mform->addElement('select', 'decimalpoints', get_string('decimalplaces', 'quiz'),

                $options);

        $mform->addHelpButton('decimalpoints', 'decimalplaces', 'quiz');

        // Question decimal points.

        $options = [-1 => get_string('sameasoverall', 'quiz')];

        for ($i = 0; $i <= QUIZ_MAX_Q_DECIMAL_OPTION; $i++) {

            $options[$i] = $i;

        }

        $mform->addElement('select', 'questiondecimalpoints',

                get_string('decimalplacesquestion', 'quiz'), $options);

        $mform->addHelpButton('questiondecimalpoints', 'decimalplacesquestion', 'quiz');

        // Show blocks during quiz attempt.

        $mform->addElement('selectyesno', 'showblocks', get_string('showblocks', 'quiz'));

        $mform->addHelpButton('showblocks', 'showblocks', 'quiz');

        // -------------------------------------------------------------------------------

        $mform->addElement('header', 'security', get_string('extraattemptrestrictions', 'quiz'));

        // Require password to begin quiz attempt.

        $mform->addElement('passwordunmask', 'quizpassword', get_string('requirepassword', 'quiz'));

        $mform->setType('quizpassword', PARAM_TEXT);

        $mform->addHelpButton('quizpassword', 'requirepassword', 'quiz');

        // IP address.

        $mform->addElement('text', 'subnet', get_string('requiresubnet', 'quiz'));

        $mform->setType('subnet', PARAM_TEXT);

        $mform->addHelpButton('subnet', 'requiresubnet', 'quiz');

        // Enforced time delay between quiz attempts.

        $mform->addElement('duration', 'delay1', get_string('delay1st2nd', 'quiz'),

                ['optional' => true]);

        $mform->addHelpButton('delay1', 'delay1st2nd', 'quiz');

        if ($this->get_max_attempts_for_any_override() < 2) {

            $mform->hideIf('delay1', 'attempts', 'eq', 1);

        }

        $mform->addElement('duration', 'delay2', get_string('delaylater', 'quiz'),

                ['optional' => true]);

        $mform->addHelpButton('delay2', 'delaylater', 'quiz');

        if ($this->get_max_attempts_for_any_override() < 3) {

            $mform->hideIf('delay2', 'attempts', 'eq', 1);

            $mform->hideIf('delay2', 'attempts', 'eq', 2);

        }

        // Browser security choices.

        $mform->addElement('select', 'browsersecurity', get_string('browsersecurity', 'quiz'),

                access_manager::get_browser_security_choices());

        $mform->addHelpButton('browsersecurity', 'browsersecurity', 'quiz');

        // Any other rule plugins.

        access_manager::add_settings_form_fields($this, $mform);

        // -------------------------------------------------------------------------------

        $mform->addElement('header', 'overallfeedbackhdr', get_string('overallfeedback', 'quiz'));

        $mform->addHelpButton('overallfeedbackhdr', 'overallfeedback', 'quiz');

        if (isset($this->current->grade)) {

            $needwarning = $this->current->grade === 0;

        } else {

            $needwarning = $quizconfig->maximumgrade == 0;

        }

        if ($needwarning) {

            $mform->addElement('static', 'nogradewarning', '',

                    get_string('nogradewarning', 'quiz'));

        }

        $mform->addElement('static', 'gradeboundarystatic1',

                get_string('gradeboundary', 'quiz'), '100%');

        $repeatarray = [];

        $repeatedoptions = [];

        $repeatarray[] = $mform->createElement('editor', 'feedbacktext',

                get_string('feedback', 'quiz'), ['rows' => 3], ['maxfiles' => EDITOR_UNLIMITED_FILES,

                        'noclean' => true, 'context' => $this->context]);

        $repeatarray[] = $mform->createElement('text', 'feedbackboundaries',

                get_string('gradeboundary', 'quiz'), ['size' => 10]);

        $repeatedoptions['feedbacktext']['type'] = PARAM_RAW;

        $repeatedoptions['feedbackboundaries']['type'] = PARAM_RAW;

        if (!empty($this->_instance)) {

            $this->_feedbacks = $DB->get_records('quiz_feedback',

                    ['quizid' => $this->_instance], 'mingrade DESC');

            $numfeedbacks = count($this->_feedbacks);

        } else {

            $this->_feedbacks = [];

            $numfeedbacks = $quizconfig->initialnumfeedbacks;

        }

        $numfeedbacks = max($numfeedbacks, 1);

        $nextel = $this->repeat_elements($repeatarray, $numfeedbacks - 1,

                $repeatedoptions, 'boundary_repeats', 'boundary_add_fields', 3,

                get_string('addmoreoverallfeedbacks', 'quiz'), true);

        // Put some extra elements in before the button.

        $mform->insertElementBefore($mform->createElement('editor',

                "feedbacktext[$nextel]", get_string('feedback', 'quiz'), ['rows' => 3],

                ['maxfiles' => EDITOR_UNLIMITED_FILES, 'noclean' => true,

                      'context' => $this->context]),

                'boundary_add_fields');

        $mform->insertElementBefore($mform->createElement('static',

                'gradeboundarystatic2', get_string('gradeboundary', 'quiz'), '0%'),

                'boundary_add_fields');

        // Add the disabledif rules. We cannot do this using the $repeatoptions parameter to

        // repeat_elements because we don't want to dissable the first feedbacktext.

        for ($i = 0; $i < $nextel; $i++) {

            $mform->disabledIf('feedbackboundaries[' . $i . ']', 'grade', 'eq', 0);

            $mform->disabledIf('feedbacktext[' . ($i + 1) . ']', 'grade', 'eq', 0);

        }

        // -------------------------------------------------------------------------------

        $this->standard_coursemodule_elements();

        // Check and act on whether setting outcomes is considered an advanced setting.

        $mform->setAdvanced('modoutcomes', !empty($quizconfig->outcomes_adv));

        // The standard_coursemodule_elements method sets this to 100, but the

        // quiz has its own setting, so use that.

        $mform->setDefault('grade', $quizconfig->maximumgrade);

        // -------------------------------------------------------------------------------

        $this->apply_admin_defaults();

        $this->add_action_buttons();

        $PAGE->requires->yui_module('moodle-mod_quiz-modform', 'M.mod_quiz.modform.init');

    }

    protected function add_review_options_group($mform, $quizconfig, $whenname,

            $when, $withhelp = false) {

        global $OUTPUT;

        $group = [];

        foreach (self::$reviewfields as $field => $string) {

            list($identifier, $component) = $string;

            $label = get_string($identifier, $component);

            $group[] = $mform->createElement('html', html_writer::start_div('review_option_item'));

            $el = $mform->createElement('checkbox', $field . $whenname, '', $label);

            if ($withhelp) {

                $el->_helpbutton = $OUTPUT->render(new help_icon($identifier, $component));

            }

            $group[] = $el;

            $group[] = $mform->createElement('html', html_writer::end_div());

        }

        $mform->addGroup($group, $whenname . 'optionsgrp',

                get_string('review' . $whenname, 'quiz'), null, false);

        foreach (self::$reviewfields as $field => $notused) {

            $cfgfield = 'review' . $field;

            if ($quizconfig->$cfgfield & $when) {

                $mform->setDefault($field . $whenname, 1);

            } else {

                $mform->setDefault($field . $whenname, 0);

            }

        }

        $mform->disabledIf('marks' . $whenname, 'maxmarks' . $whenname);

        if ($whenname != 'during') {

            $mform->disabledIf('correctness' . $whenname, 'attempt' . $whenname);

            $mform->disabledIf('specificfeedback' . $whenname, 'attempt' . $whenname);

            $mform->disabledIf('generalfeedback' . $whenname, 'attempt' . $whenname);

            $mform->disabledIf('rightanswer' . $whenname, 'attempt' . $whenname);

        }

    }

    protected function preprocessing_review_settings(&$toform, $whenname, $when) {

        foreach (self::$reviewfields as $field => $notused) {

            $fieldname = 'review' . $field;

            if (array_key_exists($fieldname, $toform)) {

                $toform[$field . $whenname] = $toform[$fieldname] & $when;

            }

        }

    }

    public function data_preprocessing(&$toform) {

        if (isset($toform['grade'])) {

            // Convert to a real number, so we don't get 0.0000.

            $toform['grade'] = $toform['grade'] + 0;

        }

        if (count($this->_feedbacks)) {

            $key = 0;

            foreach ($this->_feedbacks as $feedback) {

                $draftid = file_get_submitted_draft_itemid('feedbacktext['.$key.']');

                $toform['feedbacktext['.$key.']']['text'] = file_prepare_draft_area(

                    $draftid,               // Draftid.

                    $this->context->id,     // Context.

                    'mod_quiz',             // Component.

                    'feedback',             // Filarea.

                    !empty($feedback->id) ? (int) $feedback->id : null, // Itemid.

                    null,

                    $feedback->feedbacktext // Text.

                );

                $toform['feedbacktext['.$key.']']['format'] = $feedback->feedbacktextformat;

                $toform['feedbacktext['.$key.']']['itemid'] = $draftid;

                if ($toform['grade'] == 0) {

                    // When a quiz is un-graded, there can only be one lot of

                    // feedback. If the quiz previously had a maximum grade and

                    // several lots of feedback, we must now avoid putting text

                    // into input boxes that are disabled, but which the

                    // validation will insist are blank.

                    break;

                }

                if ($feedback->mingrade > 0) {

                    $toform['feedbackboundaries['.$key.']'] =

                            round(100.0 * $feedback->mingrade / $toform['grade'], 6) . '%';

                }

                $key++;

            }

        }

        if (isset($toform['timelimit'])) {

            $toform['timelimitenable'] = $toform['timelimit'] > 0;

        }

        $this->preprocessing_review_settings($toform, 'during',

                display_options::DURING);

        $this->preprocessing_review_settings($toform, 'immediately',

                display_options::IMMEDIATELY_AFTER);

        $this->preprocessing_review_settings($toform, 'open',

                display_options::LATER_WHILE_OPEN);

        $this->preprocessing_review_settings($toform, 'closed',

                display_options::AFTER_CLOSE);

        $toform['attemptduring'] = true;

        $toform['overallfeedbackduring'] = false;

        // Password field - different in form to stop browsers that remember

        // passwords from getting confused.

        if (isset($toform['password'])) {

            $toform['quizpassword'] = $toform['password'];

            unset($toform['password']);

        }

        // Load any settings belonging to the access rules.

        if (!empty($toform['instance'])) {

            $accesssettings = access_manager::load_settings($toform['instance']);

            foreach ($accesssettings as $name => $value) {

                $toform[$name] = $value;

            }

        }

        $suffix = $this->get_suffix();

        $completionminattemptsel = 'completionminattempts' . $suffix;

        if (empty($toform[$completionminattemptsel])) {

            $toform[$completionminattemptsel] = 1;

        } else {

            $completionminattemptsenabledel = 'completionminattemptsenabled' . $suffix;

            $toform[$completionminattemptsenabledel] = $toform[$completionminattemptsel] > 0;

        }

    }

    /**

     * Allows module to modify the data returned by form get_data().

     * This method is also called in the bulk activity completion form.

     *

     * Only available on moodleform_mod.

     *

     * @param stdClass $data the form data to be modified.

     */

    public function data_postprocessing($data) {

        parent::data_postprocessing($data);

        if (!empty($data->completionunlocked)) {

            // Turn off completion settings if the checkboxes aren't ticked.

            $suffix = $this->get_suffix();

            $completion = $data->{'completion' . $suffix};

            $autocompletion = !empty($completion) && $completion == COMPLETION_TRACKING_AUTOMATIC;

            if (empty($data->{'completionminattemptsenabled' . $suffix}) || !$autocompletion) {

                $data->{'completionminattempts' . $suffix} = 0;

            }

        }

    }

    public function validation($data, $files) {

        $errors = parent::validation($data, $files);

        // Check open and close times are consistent.

        if ($data['timeopen'] != 0 && $data['timeclose'] != 0 &&

                $data['timeclose'] < $data['timeopen']) {

            $errors['timeclose'] = get_string('closebeforeopen', 'quiz');

        }

        // Check that the grace period is not too short.

        if ($data['overduehandling'] == 'graceperiod') {

            $graceperiodmin = get_config('quiz', 'graceperiodmin');

            if ($data['graceperiod'] <= $graceperiodmin) {

                $errors['graceperiod'] = get_string('graceperiodtoosmall', 'quiz', format_time($graceperiodmin));

            }

        }

        $suffix = $this->get_suffix();

        $completionminattemptsel = 'completionminattempts' . $suffix;

        if (!empty($data[$completionminattemptsel])) {

            if ($data['attempts'] > 0 && $data[$completionminattemptsel] > $data['attempts']) {

                $completionminattemptsgroupel = 'completionminattemptsgroup' . $suffix;

                $errors[$completionminattemptsgroupel] = get_string('completionminattemptserror', 'quiz');

            }

        }

        // Check the boundary value is a number or a percentage, and in range.

        $i = 0;

        while (!empty($data['feedbackboundaries'][$i] )) {

            $boundary = trim($data['feedbackboundaries'][$i]);

            if (strlen($boundary) > 0) {

                if ($boundary[strlen($boundary) - 1] == '%') {

                    $boundary = trim(substr($boundary, 0, -1));

                    if (is_numeric($boundary)) {

                        $boundary = $boundary * $data['grade'] / 100.0;

                    } else {

                        $errors["feedbackboundaries[$i]"] =

                                get_string('feedbackerrorboundaryformat', 'quiz', $i + 1);

                    }

                } else if (!is_numeric($boundary)) {

                    $errors["feedbackboundaries[$i]"] =

                            get_string('feedbackerrorboundaryformat', 'quiz', $i + 1);

                }

            }

            if (is_numeric($boundary) && $boundary <= 0 || $boundary >= $data['grade'] ) {

                $errors["feedbackboundaries[$i]"] =

                        get_string('feedbackerrorboundaryoutofrange', 'quiz', $i + 1);

            }

            if (is_numeric($boundary) && $i > 0 &&

                    $boundary >= $data['feedbackboundaries'][$i - 1]) {

                $errors["feedbackboundaries[$i]"] =

                        get_string('feedbackerrororder', 'quiz', $i + 1);

            }

            $data['feedbackboundaries'][$i] = $boundary;

            $i += 1;

        }

        $numboundaries = $i;

        // Check there is nothing in the remaining unused fields.

        if (!empty($data['feedbackboundaries'])) {

            for ($i = $numboundaries; $i < count($data['feedbackboundaries']); $i += 1) {

                if (!empty($data['feedbackboundaries'][$i] ) &&

                        trim($data['feedbackboundaries'][$i] ) != '') {

                    $errors["feedbackboundaries[$i]"] =

                            get_string('feedbackerrorjunkinboundary', 'quiz', $i + 1);

                }

            }

        }

        for ($i = $numboundaries + 1; $i < count($data['feedbacktext']); $i += 1) {

            if (!empty($data['feedbacktext'][$i]['text']) &&

                    trim($data['feedbacktext'][$i]['text'] ) != '') {

                $errors["feedbacktext[$i]"] =

                        get_string('feedbackerrorjunkinfeedback', 'quiz', $i + 1);

            }

        }

        // If CBM is involved, don't show the warning for grade to pass being larger than the maximum grade.

        if (($data['preferredbehaviour'] == 'deferredcbm') OR ($data['preferredbehaviour'] == 'immediatecbm')) {

            unset($errors['gradepass']);

        }

        // Any other rule plugins.

        $errors = access_manager::validate_settings_form_fields($errors, $data, $files, $this);

        return $errors;

    }

    /**

     * Display module-specific activity completion rules.

     * Part of the API defined by moodleform_mod

     * @return array Array of string IDs of added items, empty array if none

     */

    public function add_completion_rules() {

        $mform = $this->_form;

        $suffix = $this->get_suffix();

        $group = [];

        $completionminattemptsenabledel = 'completionminattemptsenabled' . $suffix;

        $group[] = $mform->createElement(

            'checkbox',

            $completionminattemptsenabledel,

            '',

            get_string('completionminattempts', 'quiz')

        );

        $completionminattemptsel = 'completionminattempts' . $suffix;

        $group[] = $mform->createElement('text', $completionminattemptsel, '', ['size' => 3]);

        $mform->setType($completionminattemptsel, PARAM_INT);

        $completionminattemptsgroupel = 'completionminattemptsgroup' . $suffix;

        $mform->addGroup($group, $completionminattemptsgroupel, '', ' ', false);

        $mform->hideIf($completionminattemptsel, $completionminattemptsenabledel, 'notchecked');

        return [$completionminattemptsgroupel];

    }

    /**

     * Add completion grading elements to the form and return the list of element ids.

     *

     * @return array Array of string IDs of added items, empty array if none

     */

    public function add_completiongrade_rules(): array {

        $mform = $this->_form;

        $suffix = $this->get_suffix();

        $completionattemptsexhaustedel = 'completionattemptsexhausted' . $suffix;

        $mform->addElement(

            'advcheckbox',

            $completionattemptsexhaustedel,

            null,

            get_string('completionattemptsexhausted', 'quiz'),

            ['group' => 'cattempts', 'parentclass' => 'ms-4']

        );

        $completionpassgradeel = 'completionpassgrade' . $suffix;

        $mform->hideIf($completionattemptsexhaustedel, $completionpassgradeel, 'notchecked');

        $mform->hideIf($completionattemptsexhaustedel, $completionpassgradeel, 'notchecked');

        return [$completionattemptsexhaustedel];

    }

    /**

     * Called during validation. Indicates whether a module-specific completion rule is selected.

     *

     * @param array $data Input data (not yet validated)

     * @return bool True if one or more rules is enabled, false if none are.

     */

    public function completion_rule_enabled($data) {

        $suffix = $this->get_suffix();

        return  !empty($data['completionattemptsexhausted' . $suffix]) ||

                !empty($data['completionminattemptsenabled' . $suffix]);

    }

    /**

     * Get the maximum number of attempts that anyone might have due to a user

     * or group override. Used to decide whether disabledIf rules should be applied.

     * @return int the number of attempts allowed. For the purpose of this method,

     * unlimited is returned as 1000, not 0.

     */

    public function get_max_attempts_for_any_override() {

        global $DB;

        if (empty($this->_instance)) {

            // Quiz not created yet, so no overrides.

            return 1;

        }

        if ($this->maxattemptsanyoverride === null) {

            $this->maxattemptsanyoverride = $DB->get_field_sql("

                    SELECT MAX(CASE WHEN attempts = 0 THEN 1000 ELSE attempts END)

                      FROM {quiz_overrides}

                     WHERE quiz = ?",

                    [$this->_instance]);

            if ($this->maxattemptsanyoverride < 1) {

                // This happens when no override alters the number of attempts.

                $this->maxattemptsanyoverride = 1;

            }

        }

        return $this->maxattemptsanyoverride;

    }

}