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

/**
 * Library of functions used by the quiz module.
 *
 * This contains functions that are called from within the quiz module only
 * Functions that are also called by core Moodle are in {@link lib.php}
 * This script also loads the code in {@link questionlib.php} which holds
 * the module-indpendent code for handling questions and which in turn
 * initialises all the questiontype classes.
 *
 * @package    mod_quiz
 * @copyright  1999 onwards Martin Dougiamas and others {@link http://moodle.com}
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */


< 


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

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

< require_once($CFG->dirroot . '/mod/quiz/accessmanager.php');
< require_once($CFG->dirroot . '/mod/quiz/accessmanager_form.php');
< require_once($CFG->dirroot . '/mod/quiz/renderer.php');
< require_once($CFG->dirroot . '/mod/quiz/attemptlib.php');


require_once($CFG->libdir . '/completionlib.php');
require_once($CFG->libdir . '/filelib.php');
require_once($CFG->libdir . '/questionlib.php');


> use mod_quiz\access_manager;

> use mod_quiz\event\attempt_submitted;
/**
> use mod_quiz\grade_calculator;
 * @var int We show the countdown timer if there is less than this amount of time left before the
> use mod_quiz\question\bank\qbank_helper;
 * the quiz close date. (1 hour)
> use mod_quiz\question\display_options;
 */
> use mod_quiz\quiz_attempt;
define('QUIZ_SHOW_TIME_BEFORE_DEADLINE', '3600');
> use mod_quiz\quiz_settings;

> use qbank_previewquestion\question_preview_options;


/**
 * @var int If there are fewer than this many seconds left when the student submits
 * a page of the quiz, then do not take them to the next page of the quiz. Instead
 * close the quiz immediately.
 */
define('QUIZ_MIN_TIME_TO_CONTINUE', '2');

/**
 * @var int We show no image when user selects No image from dropdown menu in quiz settings.
 */
define('QUIZ_SHOWIMAGE_NONE', 0);

/**
 * @var int We show small image when user selects small image from dropdown menu in quiz settings.
 */
define('QUIZ_SHOWIMAGE_SMALL', 1);

/**
 * @var int We show Large image when user selects Large image from dropdown menu in quiz settings.
 */
define('QUIZ_SHOWIMAGE_LARGE', 2);


// Functions related to attempts ///////////////////////////////////////////////

/**
 * Creates an object to represent a new attempt at a quiz
 *
 * Creates an attempt object to represent an attempt at the quiz by the current
 * user starting at the current time. The ->id field is not set. The object is
 * NOT written to the database.
 *

<  * @param object $quizobj the quiz object to create an attempt for.



>  * @param quiz_settings $quizobj the quiz object to create an attempt for.


 * @param int $attemptnumber the sequence number for the attempt.

<  * @param object $lastattempt the previous attempt by this user, if any. Only needed



>  * @param stdClass|false $lastattempt the previous attempt by this user, if any. Only needed


 *         if $attemptnumber > 1 and $quiz->attemptonlast is true.
 * @param int $timenow the time the attempt was started at.
 * @param bool $ispreview whether this new attempt is a preview.

<  * @param int $userid  the id of the user attempting this quiz.



>  * @param int|null $userid  the id of the user attempting this quiz.


 *

<  * @return object the newly created attempt object.



>  * @return stdClass the newly created attempt object.


 */

< function quiz_create_attempt(quiz $quizobj, $attemptnumber, $lastattempt, $timenow, $ispreview = false, $userid = null) {



> function quiz_create_attempt(quiz_settings $quizobj, $attemptnumber, $lastattempt, $timenow, $ispreview = false, $userid = null) {


    global $USER;

    if ($userid === null) {
        $userid = $USER->id;
    }

    $quiz = $quizobj->get_quiz();

<     if ($quiz->sumgrades < 0.000005 && $quiz->grade > 0.000005) {



>     if ($quiz->sumgrades < grade_calculator::ALMOST_ZERO && $quiz->grade > grade_calculator::ALMOST_ZERO) {


        throw new moodle_exception('cannotstartgradesmismatch', 'quiz',

<                 new moodle_url('/mod/quiz/view.php', array('q' => $quiz->id)),
<                     array('grade' => quiz_format_grade($quiz, $quiz->grade)));



>                 new moodle_url('/mod/quiz/view.php', ['q' => $quiz->id]),
>                     ['grade' => quiz_format_grade($quiz, $quiz->grade)]);


    }

    if ($attemptnumber == 1 || !$quiz->attemptonlast) {
        // We are not building on last attempt so create a new attempt.
        $attempt = new stdClass();
        $attempt->quiz = $quiz->id;
        $attempt->userid = $userid;
        $attempt->preview = 0;
        $attempt->layout = '';
    } else {
        // Build on last attempt.
        if (empty($lastattempt)) {

<             print_error('cannotfindprevattempt', 'quiz');



>             throw new \moodle_exception('cannotfindprevattempt', 'quiz');


        }
        $attempt = $lastattempt;
    }

    $attempt->attempt = $attemptnumber;
    $attempt->timestart = $timenow;
    $attempt->timefinish = 0;
    $attempt->timemodified = $timenow;
    $attempt->timemodifiedoffline = 0;
    $attempt->state = quiz_attempt::IN_PROGRESS;
    $attempt->currentpage = 0;
    $attempt->sumgrades = null;

>     $attempt->gradednotificationsenttime = null;



    // If this is a preview, mark it as such.
    if ($ispreview) {
        $attempt->preview = 1;
    }

    $timeclose = $quizobj->get_access_manager($timenow)->get_end_time($attempt);
    if ($timeclose === false || $ispreview) {
        $attempt->timecheckstate = null;
    } else {
        $attempt->timecheckstate = $timeclose;
    }

    return $attempt;
}
/**
 * Start a normal, new, quiz attempt.
 *

<  * @param quiz      $quizobj            the quiz object to start an attempt for.



>  * @param quiz_settings $quizobj        the quiz object to start an attempt for.


 * @param question_usage_by_activity $quba

<  * @param object    $attempt



>  * @param stdClass    $attempt


 * @param integer   $attemptnumber      starting from 1
 * @param integer   $timenow            the attempt start time
 * @param array     $questionids        slot number => question id. Used for random questions, to force the choice
 *                                        of a particular actual question. Intended for testing purposes only.
 * @param array     $forcedvariantsbyslot slot number => variant. Used for questions with variants,
 *                                          to force the choice of a particular variant. Intended for testing
 *                                          purposes only.

<  * @throws moodle_exception
<  * @return object   modified attempt object



>  * @return stdClass   modified attempt object


 */
function quiz_start_new_attempt($quizobj, $quba, $attempt, $attemptnumber, $timenow,

<                                 $questionids = array(), $forcedvariantsbyslot = array()) {



>                                 $questionids = [], $forcedvariantsbyslot = []) {



    // Usages for this user's previous quiz attempts.
    $qubaids = new \mod_quiz\question\qubaids_for_users_attempts(
            $quizobj->get_quizid(), $attempt->userid);

    // Fully load all the questions in this quiz.
    $quizobj->preload_questions();
    $quizobj->load_questions();

    // First load all the non-random questions.
    $randomfound = false;
    $slot = 0;

<     $questions = array();
<     $maxmark = array();
<     $page = array();



>     $questions = [];
>     $maxmark = [];
>     $page = [];


    foreach ($quizobj->get_questions() as $questiondata) {
        $slot += 1;
        $maxmark[$slot] = $questiondata->maxmark;
        $page[$slot] = $questiondata->page;

>         if ($questiondata->status == \core_question\local\bank\question_version_status::QUESTION_STATUS_DRAFT) {
        if ($questiondata->qtype == 'random') {
>             throw new moodle_exception('questiondraftonly', 'mod_quiz', '', $questiondata->name);
            $randomfound = true;
>         }


            continue;
        }
        if (!$quizobj->get_quiz()->shuffleanswers) {
            $questiondata->options->shuffleanswers = false;
        }
        $questions[$slot] = question_bank::make_question($questiondata);
    }

    // Then find a question to go in place of each random question.
    if ($randomfound) {
        $slot = 0;

<         $usedquestionids = array();



>         $usedquestionids = [];


        foreach ($questions as $question) {

<             if (isset($usedquestions[$question->id])) {



>             if ($question->id && isset($usedquestions[$question->id])) {


                $usedquestionids[$question->id] += 1;
            } else {
                $usedquestionids[$question->id] = 1;
            }
        }

<         $randomloader = new \core_question\bank\random_question_loader($qubaids, $usedquestionids);



>         $randomloader = new \core_question\local\bank\random_question_loader($qubaids, $usedquestionids);



        foreach ($quizobj->get_questions() as $questiondata) {
            $slot += 1;
            if ($questiondata->qtype != 'random') {
                continue;
            }


<             $tagids = quiz_retrieve_slot_tag_ids($questiondata->slotid);



>             $tagids = qbank_helper::get_tag_ids_for_slot($questiondata);



            // Deal with fixed random choices for testing.
            if (isset($questionids[$quba->next_slot_number()])) {
                if ($randomloader->is_question_available($questiondata->category,
                        (bool) $questiondata->questiontext, $questionids[$quba->next_slot_number()], $tagids)) {
                    $questions[$slot] = question_bank::load_question(
                            $questionids[$quba->next_slot_number()], $quizobj->get_quiz()->shuffleanswers);
                    continue;
                } else {
                    throw new coding_exception('Forced question id not available.');
                }
            }

            // Normal case, pick one at random.

<             $questionid = $randomloader->get_next_question_id($questiondata->randomfromcategory,
<                     $questiondata->randomincludingsubcategories, $tagids);



>             $questionid = $randomloader->get_next_question_id($questiondata->category,
>                     $questiondata->randomrecurse, $tagids);


            if ($questionid === null) {
                throw new moodle_exception('notenoughrandomquestions', 'quiz',
                                           $quizobj->view_url(), $questiondata);
            }

            $questions[$slot] = question_bank::load_question($questionid,
                    $quizobj->get_quiz()->shuffleanswers);
        }
    }

    // Finally add them all to the usage.
    ksort($questions);
    foreach ($questions as $slot => $question) {
        $newslot = $quba->add_question($question, $maxmark[$slot]);
        if ($newslot != $slot) {
            throw new coding_exception('Slot numbers have got confused.');
        }
    }

    // Start all the questions.
    $variantstrategy = new core_question\engine\variants\least_used_strategy($quba, $qubaids);

    if (!empty($forcedvariantsbyslot)) {
        $forcedvariantsbyseed = question_variant_forced_choices_selection_strategy::prepare_forced_choices_array(
            $forcedvariantsbyslot, $quba);
        $variantstrategy = new question_variant_forced_choices_selection_strategy(
            $forcedvariantsbyseed, $variantstrategy);
    }

    $quba->start_all_questions($variantstrategy, $timenow, $attempt->userid);

    // Work out the attempt layout.
    $sections = $quizobj->get_sections();
    foreach ($sections as $i => $section) {
        if (isset($sections[$i + 1])) {
            $sections[$i]->lastslot = $sections[$i + 1]->firstslot - 1;
        } else {
            $sections[$i]->lastslot = count($questions);
        }
    }


<     $layout = array();



>     $layout = [];


    foreach ($sections as $section) {
        if ($section->shufflequestions) {

<             $questionsinthissection = array();



>             $questionsinthissection = [];


            for ($slot = $section->firstslot; $slot <= $section->lastslot; $slot += 1) {
                $questionsinthissection[] = $slot;
            }
            shuffle($questionsinthissection);
            $questionsonthispage = 0;
            foreach ($questionsinthissection as $slot) {
                if ($questionsonthispage && $questionsonthispage == $quizobj->get_quiz()->questionsperpage) {
                    $layout[] = 0;
                    $questionsonthispage = 0;
                }
                $layout[] = $slot;
                $questionsonthispage += 1;
            }

        } else {
            $currentpage = $page[$section->firstslot];
            for ($slot = $section->firstslot; $slot <= $section->lastslot; $slot += 1) {
                if ($currentpage !== null && $page[$slot] != $currentpage) {
                    $layout[] = 0;
                }
                $layout[] = $slot;
                $currentpage = $page[$slot];
            }
        }

        // Each section ends with a page break.
        $layout[] = 0;
    }
    $attempt->layout = implode(',', $layout);

    return $attempt;
}

/**
 * Start a subsequent new attempt, in each attempt builds on last mode.
 *
 * @param question_usage_by_activity    $quba         this question usage

<  * @param object                        $attempt      this attempt
<  * @param object                        $lastattempt  last attempt
<  * @return object                       modified attempt object



>  * @param stdClass                        $attempt      this attempt
>  * @param stdClass                        $lastattempt  last attempt
>  * @return stdClass                       modified attempt object


 *
 */
function quiz_start_attempt_built_on_last($quba, $attempt, $lastattempt) {
    $oldquba = question_engine::load_questions_usage_by_activity($lastattempt->uniqueid);


<     $oldnumberstonew = array();



>     $oldnumberstonew = [];


    foreach ($oldquba->get_attempt_iterator() as $oldslot => $oldqa) {

<         $newslot = $quba->add_question($oldqa->get_question(false), $oldqa->get_max_mark());



>         $question = $oldqa->get_question(false);
>         if ($question->status == \core_question\local\bank\question_version_status::QUESTION_STATUS_DRAFT) {
>             throw new moodle_exception('questiondraftonly', 'mod_quiz', '', $question->name);
>         }
>         $newslot = $quba->add_question($question, $oldqa->get_max_mark());



        $quba->start_question_based_on($newslot, $oldqa);

        $oldnumberstonew[$oldslot] = $newslot;
    }

    // Update attempt layout.

<     $newlayout = array();



>     $newlayout = [];


    foreach (explode(',', $lastattempt->layout) as $oldslot) {
        if ($oldslot != 0) {
            $newlayout[] = $oldnumberstonew[$oldslot];
        } else {
            $newlayout[] = 0;
        }
    }
    $attempt->layout = implode(',', $newlayout);
    return $attempt;
}

/**
 * The save started question usage and quiz attempt in db and log the started attempt.
 *

<  * @param quiz                       $quizobj



>  * @param quiz_settings $quizobj


 * @param question_usage_by_activity $quba

<  * @param object                     $attempt
<  * @return object                    attempt object with uniqueid and id set.



>  * @param stdClass                     $attempt
>  * @return stdClass                    attempt object with uniqueid and id set.


 */
function quiz_attempt_save_started($quizobj, $quba, $attempt) {
    global $DB;
    // Save the attempt in the database.
    question_engine::save_questions_usage_by_activity($quba);
    $attempt->uniqueid = $quba->get_id();
    $attempt->id = $DB->insert_record('quiz_attempts', $attempt);

    // Params used by the events below.

<     $params = array(



>     $params = [


        'objectid' => $attempt->id,
        'relateduserid' => $attempt->userid,
        'courseid' => $quizobj->get_courseid(),
        'context' => $quizobj->get_context()

<     );



>     ];


    // Decide which event we are using.
    if ($attempt->preview) {

<         $params['other'] = array(



>         $params['other'] = [


            'quizid' => $quizobj->get_quizid()

<         );



>         ];


        $event = \mod_quiz\event\attempt_preview_started::create($params);
    } else {
        $event = \mod_quiz\event\attempt_started::create($params);

    }

    // Trigger the event.
    $event->add_record_snapshot('quiz', $quizobj->get_quiz());
    $event->add_record_snapshot('quiz_attempts', $attempt);
    $event->trigger();

    return $attempt;
}

/**
 * Returns an unfinished attempt (if there is one) for the given
 * user on the given quiz. This function does not return preview attempts.
 *
 * @param int $quizid the id of the quiz.
 * @param int $userid the id of the user.
 *
 * @return mixed the unfinished attempt if there is one, false if not.
 */
function quiz_get_user_attempt_unfinished($quizid, $userid) {
    $attempts = quiz_get_user_attempts($quizid, $userid, 'unfinished', true);
    if ($attempts) {
        return array_shift($attempts);
    } else {
        return false;
    }
}

/**
 * Delete a quiz attempt.
 * @param mixed $attempt an integer attempt id or an attempt object
 *      (row of the quiz_attempts table).

<  * @param object $quiz the quiz object.



>  * @param stdClass $quiz the quiz object.


 */
function quiz_delete_attempt($attempt, $quiz) {
    global $DB;
    if (is_numeric($attempt)) {

<         if (!$attempt = $DB->get_record('quiz_attempts', array('id' => $attempt))) {



>         if (!$attempt = $DB->get_record('quiz_attempts', ['id' => $attempt])) {


            return;
        }
    }

    if ($attempt->quiz != $quiz->id) {
        debugging("Trying to delete attempt $attempt->id which belongs to quiz $attempt->quiz " .
                "but was passed quiz $quiz->id.");
        return;
    }

    if (!isset($quiz->cmid)) {
        $cm = get_coursemodule_from_instance('quiz', $quiz->id, $quiz->course);
        $quiz->cmid = $cm->id;
    }

    question_engine::delete_questions_usage_by_activity($attempt->uniqueid);

<     $DB->delete_records('quiz_attempts', array('id' => $attempt->id));



>     $DB->delete_records('quiz_attempts', ['id' => $attempt->id]);



    // Log the deletion of the attempt if not a preview.
    if (!$attempt->preview) {

<         $params = array(



>         $params = [


            'objectid' => $attempt->id,
            'relateduserid' => $attempt->userid,
            'context' => context_module::instance($quiz->cmid),

<             'other' => array(



>             'other' => [


                'quizid' => $quiz->id

<             )
<         );



>             ]
>         ];


        $event = \mod_quiz\event\attempt_deleted::create($params);
        $event->add_record_snapshot('quiz_attempts', $attempt);
        $event->trigger();

> 
    }
>         $callbackclasses = \core_component::get_plugin_list_with_class('quiz', 'quiz_attempt_deleted');

>         foreach ($callbackclasses as $callbackclass) {
    // Search quiz_attempts for other instances by this user.
>             component_class_callback($callbackclass, 'callback', [$quiz->id]);
    // If none, then delete record for this quiz, this user from quiz_grades
>         }


    // else recalculate best grade.
    $userid = $attempt->userid;

<     if (!$DB->record_exists('quiz_attempts', array('userid' => $userid, 'quiz' => $quiz->id))) {
<         $DB->delete_records('quiz_grades', array('userid' => $userid, 'quiz' => $quiz->id));



>     $gradecalculator = quiz_settings::create($quiz->id)->get_grade_calculator();
>     if (!$DB->record_exists('quiz_attempts', ['userid' => $userid, 'quiz' => $quiz->id])) {
>         $DB->delete_records('quiz_grades', ['userid' => $userid, 'quiz' => $quiz->id]);


    } else {

<         quiz_save_best_grade($quiz, $userid);



>         $gradecalculator->recompute_final_grade($userid);


    }

    quiz_update_grades($quiz, $userid);
}

/**
 * Delete all the preview attempts at a quiz, or possibly all the attempts belonging
 * to one user.

<  * @param object $quiz the quiz object.



>  * @param stdClass $quiz the quiz object.


 * @param int $userid (optional) if given, only delete the previews belonging to this user.
 */
function quiz_delete_previews($quiz, $userid = null) {
    global $DB;

<     $conditions = array('quiz' => $quiz->id, 'preview' => 1);



>     $conditions = ['quiz' => $quiz->id, 'preview' => 1];


    if (!empty($userid)) {
        $conditions['userid'] = $userid;
    }
    $previewattempts = $DB->get_records('quiz_attempts', $conditions);
    foreach ($previewattempts as $attempt) {
        quiz_delete_attempt($attempt, $quiz);
    }
}

/**
 * @param int $quizid The quiz id.
 * @return bool whether this quiz has any (non-preview) attempts.
 */
function quiz_has_attempts($quizid) {
    global $DB;

<     return $DB->record_exists('quiz_attempts', array('quiz' => $quizid, 'preview' => 0));



>     return $DB->record_exists('quiz_attempts', ['quiz' => $quizid, 'preview' => 0]);


}

// Functions to do with quiz layout and pages //////////////////////////////////

/**
 * Repaginate the questions in a quiz
 * @param int $quizid the id of the quiz to repaginate.
 * @param int $slotsperpage number of items to put on each page. 0 means unlimited.
 */
function quiz_repaginate_questions($quizid, $slotsperpage) {
    global $DB;
    $trans = $DB->start_delegated_transaction();


<     $sections = $DB->get_records('quiz_sections', array('quizid' => $quizid), 'firstslot ASC');
<     $firstslots = array();



>     $sections = $DB->get_records('quiz_sections', ['quizid' => $quizid], 'firstslot ASC');
>     $firstslots = [];


    foreach ($sections as $section) {
        if ((int)$section->firstslot === 1) {
            continue;
        }
        $firstslots[] = $section->firstslot;
    }


<     $slots = $DB->get_records('quiz_slots', array('quizid' => $quizid),



>     $slots = $DB->get_records('quiz_slots', ['quizid' => $quizid],


            'slot');
    $currentpage = 1;
    $slotsonthispage = 0;
    foreach ($slots as $slot) {
        if (($firstslots && in_array($slot->slot, $firstslots)) ||
            ($slotsonthispage && $slotsonthispage == $slotsperpage)) {
            $currentpage += 1;
            $slotsonthispage = 0;
        }
        if ($slot->page != $currentpage) {

<             $DB->set_field('quiz_slots', 'page', $currentpage, array('id' => $slot->id));



>             $DB->set_field('quiz_slots', 'page', $currentpage, ['id' => $slot->id]);


        }
        $slotsonthispage += 1;
    }

    $trans->allow_commit();

> 
}
>     // Log quiz re-paginated event.

>     $cm = get_coursemodule_from_instance('quiz', $quizid);
// Functions to do with quiz grades ////////////////////////////////////////////
>     $event = \mod_quiz\event\quiz_repaginated::create([

>         'context' => \context_module::instance($cm->id),
/**
>         'objectid' => $quizid,
 * Convert the raw grade stored in $attempt into a grade out of the maximum
>         'other' => [
 * grade for this quiz.
>             'slotsperpage' => $slotsperpage
 *
>         ]
 * @param float $rawgrade the unadjusted grade, fof example $attempt->sumgrades
>     ]);
 * @param object $quiz the quiz object. Only the fields grade, sumgrades and decimalpoints are used.
>     $event->trigger();
 * @param bool|string $format whether to format the results for display
> 


 *      or 'question' to format a question grade (different number of decimal places.

> // Note a lot of logic related to this is now in the grade_calculator class.



<  * @param object $quiz the quiz object. Only the fields grade, sumgrades and decimalpoints are used.



>  * @param stdClass $quiz the quiz object. Only the fields grade, sumgrades and decimalpoints are used.


 *      if the $grade is null.
 */
function quiz_rescale_grade($rawgrade, $quiz, $format = true) {
    if (is_null($rawgrade)) {
        $grade = null;

<     } else if ($quiz->sumgrades >= 0.000005) {



>     } else if ($quiz->sumgrades >= grade_calculator::ALMOST_ZERO) {


        $grade = $rawgrade * $quiz->grade / $quiz->sumgrades;
    } else {
        $grade = 0;
    }
    if ($format === 'question') {
        $grade = quiz_format_question_grade($quiz, $grade);
    } else if ($format) {
        $grade = quiz_format_grade($quiz, $grade);
    }
    return $grade;
}

/**
 * Get the feedback object for this grade on this quiz.
 *
 * @param float $grade a grade on this quiz.

<  * @param object $quiz the quiz settings.



>  * @param stdClass $quiz the quiz settings.


 * @return false|stdClass the record object or false if there is not feedback for the given grade
 * @since  Moodle 3.1
 */
function quiz_feedback_record_for_grade($grade, $quiz) {
    global $DB;

    // With CBM etc, it is possible to get -ve grades, which would then not match
    // any feedback. Therefore, we replace -ve grades with 0.
    $grade = max($grade, 0);

    $feedback = $DB->get_record_select('quiz_feedback',

<             'quizid = ? AND mingrade <= ? AND ? < maxgrade', array($quiz->id, $grade, $grade));



>             'quizid = ? AND mingrade <= ? AND ? < maxgrade', [$quiz->id, $grade, $grade]);



    return $feedback;
}

/**
 * Get the feedback text that should be show to a student who
 * got this grade on this quiz. The feedback is processed ready for diplay.
 *
 * @param float $grade a grade on this quiz.

<  * @param object $quiz the quiz settings.
<  * @param object $context the quiz context.



>  * @param stdClass $quiz the quiz settings.
>  * @param context_module $context the quiz context.


 * @return string the comment that corresponds to this grade (empty string if there is not one.
 */
function quiz_feedback_for_grade($grade, $quiz, $context) {

    if (is_null($grade)) {
        return '';
    }

    $feedback = quiz_feedback_record_for_grade($grade, $quiz);

    if (empty($feedback->feedbacktext)) {
        return '';
    }

    // Clean the text, ready for display.
    $formatoptions = new stdClass();
    $formatoptions->noclean = true;
    $feedbacktext = file_rewrite_pluginfile_urls($feedback->feedbacktext, 'pluginfile.php',
            $context->id, 'mod_quiz', 'feedback', $feedback->id);
    $feedbacktext = format_text($feedbacktext, $feedback->feedbacktextformat, $formatoptions);

    return $feedbacktext;
}

/**

<  * @param object $quiz the quiz database row.



>  * @param stdClass $quiz the quiz database row.


 * @return bool Whether this quiz has any non-blank feedback text.
 */
function quiz_has_feedback($quiz) {
    global $DB;

<     static $cache = array();



>     static $cache = [];


    if (!array_key_exists($quiz->id, $cache)) {
        $cache[$quiz->id] = quiz_has_grades($quiz) &&
                $DB->record_exists_select('quiz_feedback', "quizid = ? AND " .
                    $DB->sql_isnotempty('quiz_feedback', 'feedbacktext', false, true),

<                 array($quiz->id));



>                 [$quiz->id]);


    }
    return $cache[$quiz->id];
}

/**

<  * Update the sumgrades field of the quiz. This needs to be called whenever
<  * the grading structure of the quiz is changed. For example if a question is
<  * added or removed, or a question weight is changed.
<  *
<  * You should call {@link quiz_delete_previews()} before you call this function.
<  *
<  * @param object $quiz a quiz.
<  */
< function quiz_update_sumgrades($quiz) {
<     global $DB;
< 
<     $sql = 'UPDATE {quiz}
<             SET sumgrades = COALESCE((
<                 SELECT SUM(maxmark)
<                 FROM {quiz_slots}
<                 WHERE quizid = {quiz}.id
<             ), 0)
<             WHERE id = ?';
<     $DB->execute($sql, array($quiz->id));
<     $quiz->sumgrades = $DB->get_field('quiz', 'sumgrades', array('id' => $quiz->id));
< 
<     if ($quiz->sumgrades < 0.000005 && quiz_has_attempts($quiz->id)) {
<         // If the quiz has been attempted, and the sumgrades has been
<         // set to 0, then we must also set the maximum possible grade to 0, or
<         // we will get a divide by zero error.
<         quiz_set_grade(0, $quiz);
<     }
< }
< 
< /**
<  * Update the sumgrades field of the attempts at a quiz.



>  * Return summary of the number of settings override that exist.


 *

<  * @param object $quiz a quiz.
<  */
< function quiz_update_all_attempt_sumgrades($quiz) {
<     global $DB;
<     $dm = new question_engine_data_mapper();
<     $timenow = time();
< 
<     $sql = "UPDATE {quiz_attempts}
<             SET
<                 timemodified = :timenow,
<                 sumgrades = (
<                     {$dm->sum_usage_marks_subquery('uniqueid')}
<                 )
<             WHERE quiz = :quizid AND state = :finishedstate";
<     $DB->execute($sql, array('timenow' => $timenow, 'quizid' => $quiz->id,
<             'finishedstate' => quiz_attempt::FINISHED));
< }
< 
< /**
<  * The quiz grade is the maximum that student's results are marked out of. When it
<  * changes, the corresponding data in quiz_grades and quiz_feedback needs to be
<  * rescaled. After calling this function, you probably need to call
<  * quiz_update_all_attempt_sumgrades, quiz_update_all_final_grades and
<  * quiz_update_grades.



>  * To get a nice display of this, see the quiz_override_summary_links()
>  * quiz renderer method.


 *

<  * @param float $newgrade the new maximum grade for the quiz.
<  * @param object $quiz the quiz we are updating. Passed by reference so its
<  *      grade field can be updated too.
<  * @return bool indicating success or failure.
<  */
< function quiz_set_grade($newgrade, $quiz) {
<     global $DB;
<     // This is potentially expensive, so only do it if necessary.
<     if (abs($quiz->grade - $newgrade) < 1e-7) {
<         // Nothing to do.
<         return true;
<     }
< 
<     $oldgrade = $quiz->grade;
<     $quiz->grade = $newgrade;
< 
<     // Use a transaction, so that on those databases that support it, this is safer.
<     $transaction = $DB->start_delegated_transaction();
< 
<     // Update the quiz table.
<     $DB->set_field('quiz', 'grade', $newgrade, array('id' => $quiz->instance));
< 
<     if ($oldgrade < 1) {
<         // If the old grade was zero, we cannot rescale, we have to recompute.
<         // We also recompute if the old grade was too small to avoid underflow problems.
<         quiz_update_all_final_grades($quiz);
< 
<     } else {
<         // We can rescale the grades efficiently.
<         $timemodified = time();
<         $DB->execute("
<                 UPDATE {quiz_grades}
<                 SET grade = ? * grade, timemodified = ?
<                 WHERE quiz = ?
<         ", array($newgrade/$oldgrade, $timemodified, $quiz->id));
<     }
< 
<     if ($oldgrade > 1e-7) {
<         // Update the quiz_feedback table.
<         $factor = $newgrade/$oldgrade;
<         $DB->execute("
<                 UPDATE {quiz_feedback}
<                 SET mingrade = ? * mingrade, maxgrade = ? * maxgrade
<                 WHERE quizid = ?
<         ", array($factor, $factor, $quiz->id));
<     }
< 
<     // Update grade item and send all grades to gradebook.
<     quiz_grade_item_update($quiz);
<     quiz_update_grades($quiz);
< 
<     $transaction->allow_commit();
<     return true;
< }
< 
< /**
<  * Save the overall grade for a user at a quiz in the quiz_grades table
<  *
<  * @param object $quiz The quiz for which the best grade is to be calculated and then saved.
<  * @param int $userid The userid to calculate the grade for. Defaults to the current user.
<  * @param array $attempts The attempts of this user. Useful if you are
<  * looping through many users. Attempts can be fetched in one master query to
<  * avoid repeated querying.
<  * @return bool Indicates success or failure.
<  */
< function quiz_save_best_grade($quiz, $userid = null, $attempts = array()) {
<     global $DB, $OUTPUT, $USER;
< 
<     if (empty($userid)) {
<         $userid = $USER->id;
<     }
< 
<     if (!$attempts) {
<         // Get all the attempts made by the user.
<         $attempts = quiz_get_user_attempts($quiz->id, $userid);
<     }
< 
<     // Calculate the best grade.
<     $bestgrade = quiz_calculate_best_grade($quiz, $attempts);
<     $bestgrade = quiz_rescale_grade($bestgrade, $quiz, false);
< 
<     // Save the best grade in the database.
<     if (is_null($bestgrade)) {
<         $DB->delete_records('quiz_grades', array('quiz' => $quiz->id, 'userid' => $userid));
< 
<     } else if ($grade = $DB->get_record('quiz_grades',
<             array('quiz' => $quiz->id, 'userid' => $userid))) {
<         $grade->grade = $bestgrade;
<         $grade->timemodified = time();
<         $DB->update_record('quiz_grades', $grade);
< 
<     } else {
<         $grade = new stdClass();
<         $grade->quiz = $quiz->id;
<         $grade->userid = $userid;
<         $grade->grade = $bestgrade;
<         $grade->timemodified = time();
<         $DB->insert_record('quiz_grades', $grade);
<     }
< 
<     quiz_update_grades($quiz, $userid);
< }
< 
< /**
<  * Calculate the overall grade for a quiz given a number of attempts by a particular user.
<  *
<  * @param object $quiz    the quiz settings object.
<  * @param array $attempts an array of all the user's attempts at this quiz in order.
<  * @return float          the overall grade
<  */
< function quiz_calculate_best_grade($quiz, $attempts) {
< 
<     switch ($quiz->grademethod) {
< 
<         case QUIZ_ATTEMPTFIRST:
<             $firstattempt = reset($attempts);
<             return $firstattempt->sumgrades;
< 
<         case QUIZ_ATTEMPTLAST:
<             $lastattempt = end($attempts);
<             return $lastattempt->sumgrades;
< 
<         case QUIZ_GRADEAVERAGE:
<             $sum = 0;
<             $count = 0;
<             foreach ($attempts as $attempt) {
<                 if (!is_null($attempt->sumgrades)) {
<                     $sum += $attempt->sumgrades;
<                     $count++;
<                 }
<             }
<             if ($count == 0) {
<                 return null;
<             }
<             return $sum / $count;
< 
<         case QUIZ_GRADEHIGHEST:
<         default:
<             $max = null;
<             foreach ($attempts as $attempt) {
<                 if ($attempt->sumgrades > $max) {
<                     $max = $attempt->sumgrades;
<                 }
<             }
<             return $max;
<     }
< }
< 
< /**
<  * Update the final grade at this quiz for all students.
<  *
<  * This function is equivalent to calling quiz_save_best_grade for all
<  * users, but much more efficient.
<  *
<  * @param object $quiz the quiz settings.
<  */
< function quiz_update_all_final_grades($quiz) {
<     global $DB;
< 
<     if (!$quiz->sumgrades) {
<         return;
<     }
< 
<     $param = array('iquizid' => $quiz->id, 'istatefinished' => quiz_attempt::FINISHED);
<     $firstlastattemptjoin = "JOIN (
<             SELECT
<                 iquiza.userid,
<                 MIN(attempt) AS firstattempt,
<                 MAX(attempt) AS lastattempt
< 
<             FROM {quiz_attempts} iquiza
< 
<             WHERE
<                 iquiza.state = :istatefinished AND
<                 iquiza.preview = 0 AND
<                 iquiza.quiz = :iquizid
< 
<             GROUP BY iquiza.userid
<         ) first_last_attempts ON first_last_attempts.userid = quiza.userid";
< 
<     switch ($quiz->grademethod) {
<         case QUIZ_ATTEMPTFIRST:
<             // Because of the where clause, there will only be one row, but we
<             // must still use an aggregate function.
<             $select = 'MAX(quiza.sumgrades)';
<             $join = $firstlastattemptjoin;
<             $where = 'quiza.attempt = first_last_attempts.firstattempt AND';
<             break;
< 
<         case QUIZ_ATTEMPTLAST:
<             // Because of the where clause, there will only be one row, but we
<             // must still use an aggregate function.
<             $select = 'MAX(quiza.sumgrades)';
<             $join = $firstlastattemptjoin;
<             $where = 'quiza.attempt = first_last_attempts.lastattempt AND';
<             break;
< 
<         case QUIZ_GRADEAVERAGE:
<             $select = 'AVG(quiza.sumgrades)';
<             $join = '';
<             $where = '';
<             break;
< 
<         default:
<         case QUIZ_GRADEHIGHEST:
<             $select = 'MAX(quiza.sumgrades)';
<             $join = '';
<             $where = '';
<             break;
<     }
< 
<     if ($quiz->sumgrades >= 0.000005) {
<         $finalgrade = $select . ' * ' . ($quiz->grade / $quiz->sumgrades);
<     } else {
<         $finalgrade = '0';
<     }
<     $param['quizid'] = $quiz->id;
<     $param['quizid2'] = $quiz->id;
<     $param['quizid3'] = $quiz->id;
<     $param['quizid4'] = $quiz->id;
<     $param['statefinished'] = quiz_attempt::FINISHED;
<     $param['statefinished2'] = quiz_attempt::FINISHED;
<     $finalgradesubquery = "
<             SELECT quiza.userid, $finalgrade AS newgrade
<             FROM {quiz_attempts} quiza
<             $join
<             WHERE
<                 $where
<                 quiza.state = :statefinished AND
<                 quiza.preview = 0 AND
<                 quiza.quiz = :quizid3
<             GROUP BY quiza.userid";
< 
<     $changedgrades = $DB->get_records_sql("
<             SELECT users.userid, qg.id, qg.grade, newgrades.newgrade
< 
<             FROM (
<                 SELECT userid
<                 FROM {quiz_grades} qg
<                 WHERE quiz = :quizid
<             UNION
<                 SELECT DISTINCT userid
<                 FROM {quiz_attempts} quiza2
<                 WHERE
<                     quiza2.state = :statefinished2 AND
<                     quiza2.preview = 0 AND
<                     quiza2.quiz = :quizid2
<             ) users
< 
<             LEFT JOIN {quiz_grades} qg ON qg.userid = users.userid AND qg.quiz = :quizid4
< 
<             LEFT JOIN (
<                 $finalgradesubquery
<             ) newgrades ON newgrades.userid = users.userid
< 
<             WHERE
<                 ABS(newgrades.newgrade - qg.grade) > 0.000005 OR
<                 ((newgrades.newgrade IS NULL OR qg.grade IS NULL) AND NOT
<                           (newgrades.newgrade IS NULL AND qg.grade IS NULL))",
<                 // The mess on the previous line is detecting where the value is
<                 // NULL in one column, and NOT NULL in the other, but SQL does
<                 // not have an XOR operator, and MS SQL server can't cope with
<                 // (newgrades.newgrade IS NULL) <> (qg.grade IS NULL).
<             $param);
< 
<     $timenow = time();
<     $todelete = array();
<     foreach ($changedgrades as $changedgrade) {
< 
<         if (is_null($changedgrade->newgrade)) {
<             $todelete[] = $changedgrade->userid;
< 
<         } else if (is_null($changedgrade->grade)) {
<             $toinsert = new stdClass();
<             $toinsert->quiz = $quiz->id;
<             $toinsert->userid = $changedgrade->userid;
<             $toinsert->timemodified = $timenow;
<             $toinsert->grade = $changedgrade->newgrade;
<             $DB->insert_record('quiz_grades', $toinsert);
< 
<         } else {
<             $toupdate = new stdClass();
<             $toupdate->id = $changedgrade->id;
<             $toupdate->grade = $changedgrade->newgrade;
<             $toupdate->timemodified = $timenow;
<             $DB->update_record('quiz_grades', $toupdate);
<         }
<     }



>  * @param stdClass $quiz the quiz settings. Only $quiz->id is used at the moment.
>  * @param cm_info|stdClass $cm the cm object. Only $cm->course, $cm->groupmode and
>  *      $cm->groupingid fields are used at the moment.
>  * @param int $currentgroup if there is a concept of current group where this method is being called
>  *      (e.g. a report) pass it in here. Default 0 which means no current group.
>  * @return array like 'group' => 3, 'user' => 12] where 3 is the number of group overrides,
>  *      and 12 is the number of user ones.
>  */
> function quiz_override_summary(stdClass $quiz, cm_info|stdClass $cm, int $currentgroup = 0): array {
>     global $DB;
> 
>     if ($currentgroup) {
>         // Currently only interested in one group.
>         $groupcount = $DB->count_records('quiz_overrides', ['quiz' => $quiz->id, 'groupid' => $currentgroup]);
>         $usercount = $DB->count_records_sql("
>                 SELECT COUNT(1)
>                   FROM {quiz_overrides} o
>                   JOIN {groups_members} gm ON o.userid = gm.userid
>                  WHERE o.quiz = ?
>                    AND gm.groupid = ?
>                     ", [$quiz->id, $currentgroup]);
>         return ['group' => $groupcount, 'user' => $usercount, 'mode' => 'onegroup'];
>     }
> 
>     $quizgroupmode = groups_get_activity_groupmode($cm);
>     $accessallgroups = ($quizgroupmode == NOGROUPS) ||
>             has_capability('moodle/site:accessallgroups', context_module::instance($cm->id));
> 
>     if ($accessallgroups) {
>         // User can see all groups.
>         $groupcount = $DB->count_records_select('quiz_overrides',
>                 'quiz = ? AND groupid IS NOT NULL', [$quiz->id]);
>         $usercount = $DB->count_records_select('quiz_overrides',
>                 'quiz = ? AND userid IS NOT NULL', [$quiz->id]);
>         return ['group' => $groupcount, 'user' => $usercount, 'mode' => 'allgroups'];
> 
>     } else {
>         // User can only see groups they are in.
>         $groups = groups_get_activity_allowed_groups($cm);
>         if (!$groups) {
>             return ['group' => 0, 'user' => 0, 'mode' => 'somegroups'];
>         }
> 
>         list($groupidtest, $params) = $DB->get_in_or_equal(array_keys($groups));
>         $params[] = $quiz->id;
> 
>         $groupcount = $DB->count_records_select('quiz_overrides',
>                 "groupid $groupidtest AND quiz = ?", $params);
>         $usercount = $DB->count_records_sql("
>                 SELECT COUNT(1)
>                   FROM {quiz_overrides} o
>                   JOIN {groups_members} gm ON o.userid = gm.userid
>                  WHERE gm.groupid $groupidtest
>                    AND o.quiz = ?
>                ", $params);




<     if (!empty($todelete)) {
<         list($test, $params) = $DB->get_in_or_equal($todelete);
<         $DB->delete_records_select('quiz_grades', 'quiz = ? AND userid ' . $test,
<                 array_merge(array($quiz->id), $params));



>         return ['group' => $groupcount, 'user' => $usercount, 'mode' => 'somegroups'];


    }
}

/**
 * Efficiently update check state time on all open attempts
 *
 * @param array $conditions optional restrictions on which attempts to update
 *                    Allowed conditions:
 *                      courseid => (array|int) attempts in given course(s)
 *                      userid   => (array|int) attempts for given user(s)
 *                      quizid   => (array|int) attempts in given quiz(s)
 *                      groupid  => (array|int) quizzes with some override for given group(s)
 *
 */
function quiz_update_open_attempts(array $conditions) {
    global $DB;

    foreach ($conditions as &$value) {
        if (!is_array($value)) {

<             $value = array($value);



>             $value = [$value];


        }
    }


<     $params = array();
<     $wheres = array("quiza.state IN ('inprogress', 'overdue')");
<     $iwheres = array("iquiza.state IN ('inprogress', 'overdue')");



>     $params = [];
>     $wheres = ["quiza.state IN ('inprogress', 'overdue')"];
>     $iwheres = ["iquiza.state IN ('inprogress', 'overdue')"];



    if (isset($conditions['courseid'])) {
        list ($incond, $inparams) = $DB->get_in_or_equal($conditions['courseid'], SQL_PARAMS_NAMED, 'cid');
        $params = array_merge($params, $inparams);
        $wheres[] = "quiza.quiz IN (SELECT q.id FROM {quiz} q WHERE q.course $incond)";
        list ($incond, $inparams) = $DB->get_in_or_equal($conditions['courseid'], SQL_PARAMS_NAMED, 'icid');
        $params = array_merge($params, $inparams);
        $iwheres[] = "iquiza.quiz IN (SELECT q.id FROM {quiz} q WHERE q.course $incond)";
    }

    if (isset($conditions['userid'])) {
        list ($incond, $inparams) = $DB->get_in_or_equal($conditions['userid'], SQL_PARAMS_NAMED, 'uid');
        $params = array_merge($params, $inparams);
        $wheres[] = "quiza.userid $incond";
        list ($incond, $inparams) = $DB->get_in_or_equal($conditions['userid'], SQL_PARAMS_NAMED, 'iuid');
        $params = array_merge($params, $inparams);
        $iwheres[] = "iquiza.userid $incond";
    }

    if (isset($conditions['quizid'])) {
        list ($incond, $inparams) = $DB->get_in_or_equal($conditions['quizid'], SQL_PARAMS_NAMED, 'qid');
        $params = array_merge($params, $inparams);
        $wheres[] = "quiza.quiz $incond";
        list ($incond, $inparams) = $DB->get_in_or_equal($conditions['quizid'], SQL_PARAMS_NAMED, 'iqid');
        $params = array_merge($params, $inparams);
        $iwheres[] = "iquiza.quiz $incond";
    }

    if (isset($conditions['groupid'])) {
        list ($incond, $inparams) = $DB->get_in_or_equal($conditions['groupid'], SQL_PARAMS_NAMED, 'gid');
        $params = array_merge($params, $inparams);
        $wheres[] = "quiza.quiz IN (SELECT qo.quiz FROM {quiz_overrides} qo WHERE qo.groupid $incond)";
        list ($incond, $inparams) = $DB->get_in_or_equal($conditions['groupid'], SQL_PARAMS_NAMED, 'igid');
        $params = array_merge($params, $inparams);
        $iwheres[] = "iquiza.quiz IN (SELECT qo.quiz FROM {quiz_overrides} qo WHERE qo.groupid $incond)";
    }

    // SQL to compute timeclose and timelimit for each attempt:
    $quizausersql = quiz_get_attempt_usertime_sql(
            implode("\n                AND ", $iwheres));

    // SQL to compute the new timecheckstate
    $timecheckstatesql = "
          CASE WHEN quizauser.usertimelimit = 0 AND quizauser.usertimeclose = 0 THEN NULL
               WHEN quizauser.usertimelimit = 0 THEN quizauser.usertimeclose
               WHEN quizauser.usertimeclose = 0 THEN quiza.timestart + quizauser.usertimelimit
               WHEN quiza.timestart + quizauser.usertimelimit < quizauser.usertimeclose THEN quiza.timestart + quizauser.usertimelimit
               ELSE quizauser.usertimeclose END +
          CASE WHEN quiza.state = 'overdue' THEN quiz.graceperiod ELSE 0 END";

    // SQL to select which attempts to process
    $attemptselect = implode("\n                         AND ", $wheres);

   /*
    * Each database handles updates with inner joins differently:
    *  - mysql does not allow a FROM clause
    *  - postgres and mssql allow FROM but handle table aliases differently
    *  - oracle requires a subquery
    *
    * Different code for each database.
    */

    $dbfamily = $DB->get_dbfamily();
    if ($dbfamily == 'mysql') {
        $updatesql = "UPDATE {quiz_attempts} quiza
                        JOIN {quiz} quiz ON quiz.id = quiza.quiz
                        JOIN ( $quizausersql ) quizauser ON quizauser.id = quiza.id
                         SET quiza.timecheckstate = $timecheckstatesql
                       WHERE $attemptselect";
    } else if ($dbfamily == 'postgres') {
        $updatesql = "UPDATE {quiz_attempts} quiza
                         SET timecheckstate = $timecheckstatesql
                        FROM {quiz} quiz, ( $quizausersql ) quizauser
                       WHERE quiz.id = quiza.quiz
                         AND quizauser.id = quiza.id
                         AND $attemptselect";
    } else if ($dbfamily == 'mssql') {
        $updatesql = "UPDATE quiza
                         SET timecheckstate = $timecheckstatesql
                        FROM {quiz_attempts} quiza
                        JOIN {quiz} quiz ON quiz.id = quiza.quiz
                        JOIN ( $quizausersql ) quizauser ON quizauser.id = quiza.id
                       WHERE $attemptselect";
    } else {
        // oracle, sqlite and others
        $updatesql = "UPDATE {quiz_attempts} quiza
                         SET timecheckstate = (
                           SELECT $timecheckstatesql
                             FROM {quiz} quiz, ( $quizausersql ) quizauser
                            WHERE quiz.id = quiza.quiz
                              AND quizauser.id = quiza.id
                         )
                         WHERE $attemptselect";
    }

    $DB->execute($updatesql, $params);
}

/**
 * Returns SQL to compute timeclose and timelimit for every attempt, taking into account user and group overrides.
 * The query used herein is very similar to the one in function quiz_get_user_timeclose, so, in case you
 * would change either one of them, make sure to apply your changes to both.
 *
 * @param string $redundantwhereclauses extra where clauses to add to the subquery
 *      for performance. These can use the table alias iquiza for the quiz attempts table.
 * @return string SQL select with columns attempt.id, usertimeclose, usertimelimit.
 */
function quiz_get_attempt_usertime_sql($redundantwhereclauses = '') {
    if ($redundantwhereclauses) {
        $redundantwhereclauses = 'WHERE ' . $redundantwhereclauses;
    }
    // The multiple qgo JOINS are necessary because we want timeclose/timelimit = 0 (unlimited) to supercede
    // any other group override
    $quizausersql = "
          SELECT iquiza.id,
           COALESCE(MAX(quo.timeclose), MAX(qgo1.timeclose), MAX(qgo2.timeclose), iquiz.timeclose) AS usertimeclose,
           COALESCE(MAX(quo.timelimit), MAX(qgo3.timelimit), MAX(qgo4.timelimit), iquiz.timelimit) AS usertimelimit

           FROM {quiz_attempts} iquiza
           JOIN {quiz} iquiz ON iquiz.id = iquiza.quiz
      LEFT JOIN {quiz_overrides} quo ON quo.quiz = iquiza.quiz AND quo.userid = iquiza.userid
      LEFT JOIN {groups_members} gm ON gm.userid = iquiza.userid
      LEFT JOIN {quiz_overrides} qgo1 ON qgo1.quiz = iquiza.quiz AND qgo1.groupid = gm.groupid AND qgo1.timeclose = 0
      LEFT JOIN {quiz_overrides} qgo2 ON qgo2.quiz = iquiza.quiz AND qgo2.groupid = gm.groupid AND qgo2.timeclose > 0
      LEFT JOIN {quiz_overrides} qgo3 ON qgo3.quiz = iquiza.quiz AND qgo3.groupid = gm.groupid AND qgo3.timelimit = 0
      LEFT JOIN {quiz_overrides} qgo4 ON qgo4.quiz = iquiza.quiz AND qgo4.groupid = gm.groupid AND qgo4.timelimit > 0
          $redundantwhereclauses
       GROUP BY iquiza.id, iquiz.id, iquiz.timeclose, iquiz.timelimit";
    return $quizausersql;
}

/**

<  * Return the attempt with the best grade for a quiz
<  *
<  * Which attempt is the best depends on $quiz->grademethod. If the grade
<  * method is GRADEAVERAGE then this function simply returns the last attempt.
<  * @return object         The attempt with the best grade
<  * @param object $quiz    The quiz for which the best grade is to be calculated
<  * @param array $attempts An array of all the attempts of the user at the quiz
<  */
< function quiz_calculate_best_attempt($quiz, $attempts) {
< 
<     switch ($quiz->grademethod) {
< 
<         case QUIZ_ATTEMPTFIRST:
<             foreach ($attempts as $attempt) {
<                 return $attempt;
<             }
<             break;
< 
<         case QUIZ_GRADEAVERAGE: // We need to do something with it.
<         case QUIZ_ATTEMPTLAST:
<             foreach ($attempts as $attempt) {
<                 $final = $attempt;
<             }
<             return $final;
< 
<         default:
<         case QUIZ_GRADEHIGHEST:
<             $max = -1;
<             foreach ($attempts as $attempt) {
<                 if ($attempt->sumgrades > $max) {
<                     $max = $attempt->sumgrades;
<                     $maxattempt = $attempt;
<                 }
<             }
<             return $maxattempt;
<     }
< }
< 
< /**


 * @return array int => lang string the options for calculating the quiz grade
 *      from the individual attempt grades.
 */
function quiz_get_grading_options() {

<     return array(



>     return [


        QUIZ_GRADEHIGHEST => get_string('gradehighest', 'quiz'),
        QUIZ_GRADEAVERAGE => get_string('gradeaverage', 'quiz'),
        QUIZ_ATTEMPTFIRST => get_string('attemptfirst', 'quiz'),
        QUIZ_ATTEMPTLAST  => get_string('attemptlast', 'quiz')

<     );



>     ];


}

/**
 * @param int $option one of the values QUIZ_GRADEHIGHEST, QUIZ_GRADEAVERAGE,
 *      QUIZ_ATTEMPTFIRST or QUIZ_ATTEMPTLAST.
 * @return the lang string for that option.
 */
function quiz_get_grading_option_name($option) {
    $strings = quiz_get_grading_options();
    return $strings[$option];
}

/**
 * @return array string => lang string the options for handling overdue quiz
 *      attempts.
 */
function quiz_get_overdue_handling_options() {

<     return array(



>     return [


        'autosubmit'  => get_string('overduehandlingautosubmit', 'quiz'),
        'graceperiod' => get_string('overduehandlinggraceperiod', 'quiz'),
        'autoabandon' => get_string('overduehandlingautoabandon', 'quiz'),

<     );



>     ];


}

/**
 * Get the choices for what size user picture to show.
 * @return array string => lang string the options for whether to display the user's picture.
 */
function quiz_get_user_image_options() {

<     return array(



>     return [


        QUIZ_SHOWIMAGE_NONE  => get_string('shownoimage', 'quiz'),
        QUIZ_SHOWIMAGE_SMALL => get_string('showsmallimage', 'quiz'),
        QUIZ_SHOWIMAGE_LARGE => get_string('showlargeimage', 'quiz'),

<     );



>     ];


}

/**
 * Return an user's timeclose for all quizzes in a course, hereby taking into account group and user overrides.
 *
 * @param int $courseid the course id.

<  * @return object An object with of all quizids and close unixdates in this course, taking into account the most lenient



>  * @return stdClass An object with of all quizids and close unixdates in this course, taking into account the most lenient


 * overrides, if existing and 0 if no close date is set.
 */
function quiz_get_user_timeclose($courseid) {
    global $DB, $USER;

    // For teacher and manager/admins return timeclose.
    if (has_capability('moodle/course:update', context_course::instance($courseid))) {
        $sql = "SELECT quiz.id, quiz.timeclose AS usertimeclose
                  FROM {quiz} quiz
                 WHERE quiz.course = :courseid";


<         $results = $DB->get_records_sql($sql, array('courseid' => $courseid));



>         $results = $DB->get_records_sql($sql, ['courseid' => $courseid]);


        return $results;
    }

    $sql = "SELECT q.id,
  COALESCE(v.userclose, v.groupclose, q.timeclose, 0) AS usertimeclose
  FROM (
      SELECT quiz.id as quizid,
             MAX(quo.timeclose) AS userclose, MAX(qgo.timeclose) AS groupclose
       FROM {quiz} quiz
  LEFT JOIN {quiz_overrides} quo on quiz.id = quo.quiz AND quo.userid = :userid
  LEFT JOIN {groups_members} gm ON gm.userid = :useringroupid
  LEFT JOIN {quiz_overrides} qgo on quiz.id = qgo.quiz AND qgo.groupid = gm.groupid
      WHERE quiz.course = :courseid
   GROUP BY quiz.id) v
       JOIN {quiz} q ON q.id = v.quizid";


<     $results = $DB->get_records_sql($sql, array('userid' => $USER->id, 'useringroupid' => $USER->id, 'courseid' => $courseid));



>     $results = $DB->get_records_sql($sql, ['userid' => $USER->id, 'useringroupid' => $USER->id, 'courseid' => $courseid]);


    return $results;

}

/**
 * Get the choices to offer for the 'Questions per page' option.
 * @return array int => string.
 */
function quiz_questions_per_page_options() {

<     $pageoptions = array();



>     $pageoptions = [];


    $pageoptions[0] = get_string('neverallononepage', 'quiz');
    $pageoptions[1] = get_string('everyquestion', 'quiz');
    for ($i = 2; $i <= QUIZ_MAX_QPP_OPTION; ++$i) {
        $pageoptions[$i] = get_string('everynquestions', 'quiz', $i);
    }
    return $pageoptions;
}

/**
 * Get the human-readable name for a quiz attempt state.

<  * @param string $state one of the state constants like {@link quiz_attempt::IN_PROGRESS}.



>  * @param string $state one of the state constants like {@see quiz_attempt::IN_PROGRESS}.


 * @return string The lang string to describe that state.
 */
function quiz_attempt_state_name($state) {
    switch ($state) {
        case quiz_attempt::IN_PROGRESS:
            return get_string('stateinprogress', 'quiz');
        case quiz_attempt::OVERDUE:
            return get_string('stateoverdue', 'quiz');
        case quiz_attempt::FINISHED:
            return get_string('statefinished', 'quiz');
        case quiz_attempt::ABANDONED:
            return get_string('stateabandoned', 'quiz');
        default:
            throw new coding_exception('Unknown quiz attempt state.');
    }
}

// Other quiz functions ////////////////////////////////////////////////////////

/**

<  * @param object $quiz the quiz.



>  * @param stdClass $quiz the quiz.


 * @param int $cmid the course_module object for this quiz.

<  * @param object $question the question.



>  * @param stdClass $question the question.


 * @param string $returnurl url to return to after action is done.
 * @param int $variant which question variant to preview (optional).
 * @return string html for a number of icons linked to action pages for a
 * question - preview and edit / view icons depending on user capabilities.
 */
function quiz_question_action_icons($quiz, $cmid, $question, $returnurl, $variant = null) {

<     $html = quiz_question_preview_button($quiz, $question, false, $variant) . ' ' .
<             quiz_question_edit_button($cmid, $question, $returnurl);



>     $html = '';
>     if ($question->qtype !== 'random') {
>         $html = quiz_question_preview_button($quiz, $question, false, $variant);
>     }
>     $html .= quiz_question_edit_button($cmid, $question, $returnurl);


    return $html;
}

/**
 * @param int $cmid the course_module.id for this quiz.

<  * @param object $question the question.



>  * @param stdClass $question the question.


 * @param string $returnurl url to return to after action is done.
 * @param string $contentbeforeicon some HTML content to be added inside the link, before the icon.
 * @return the HTML for an edit icon, view icon, or nothing for a question
 *      (depending on permissions).
 */
function quiz_question_edit_button($cmid, $question, $returnurl, $contentaftericon = '') {
    global $CFG, $OUTPUT;

    // Minor efficiency saving. Only get strings once, even if there are a lot of icons on one page.
    static $stredit = null;
    static $strview = null;
    if ($stredit === null) {
        $stredit = get_string('edit');
        $strview = get_string('view');
    }

    // What sort of icon should we show?
    $action = '';
    if (!empty($question->id) &&
            (question_has_capability_on($question, 'edit') ||
                    question_has_capability_on($question, 'move'))) {
        $action = $stredit;
        $icon = 't/edit';
    } else if (!empty($question->id) &&
            question_has_capability_on($question, 'view')) {
        $action = $strview;
        $icon = 'i/info';
    }

    // Build the icon.
    if ($action) {
        if ($returnurl instanceof moodle_url) {
            $returnurl = $returnurl->out_as_local_url(false);
        }

<         $questionparams = array('returnurl' => $returnurl, 'cmid' => $cmid, 'id' => $question->id);
<         $questionurl = new moodle_url("$CFG->wwwroot/question/question.php", $questionparams);



>         $questionparams = ['returnurl' => $returnurl, 'cmid' => $cmid, 'id' => $question->id];
>         $questionurl = new moodle_url("$CFG->wwwroot/question/bank/editquestion/question.php", $questionparams);


        return '<a title="' . $action . '" href="' . $questionurl->out() . '" class="questioneditbutton">' .
                $OUTPUT->pix_icon($icon, $action) . $contentaftericon .
                '</a>';
    } else if ($contentaftericon) {
        return '<span class="questioneditbutton">' . $contentaftericon . '</span>';
    } else {
        return '';
    }
}

/**

<  * @param object $quiz the quiz settings
<  * @param object $question the question



>  * @param stdClass $quiz the quiz settings
>  * @param stdClass $question the question


 * @param int $variant which question variant to preview (optional).

>  * @param int $restartversion version of the question to use when restarting the preview.


 * @return moodle_url to preview this question with the options from this quiz.
 */

< function quiz_question_preview_url($quiz, $question, $variant = null) {



> function quiz_question_preview_url($quiz, $question, $variant = null, $restartversion = null) {


    // Get the appropriate display options.

<     $displayoptions = mod_quiz_display_options::make_from_quiz($quiz,
<             mod_quiz_display_options::DURING);



>     $displayoptions = display_options::make_from_quiz($quiz,
>             display_options::DURING);



    $maxmark = null;
    if (isset($question->maxmark)) {
        $maxmark = $question->maxmark;
    }

    // Work out the correcte preview URL.

<     return question_preview_url($question->id, $quiz->preferredbehaviour,
<             $maxmark, $displayoptions, $variant);



>     return \qbank_previewquestion\helper::question_preview_url($question->id, $quiz->preferredbehaviour,
>             $maxmark, $displayoptions, $variant, null, null, $restartversion);


}

/**

<  * @param object $quiz the quiz settings
<  * @param object $question the question



>  * @param stdClass $quiz the quiz settings
>  * @param stdClass $question the question


 * @param bool $label if true, show the preview question label after the icon
 * @param int $variant which question variant to preview (optional).

<  * @return the HTML for a preview question icon.



>  * @param bool $random if question is random, true.
>  * @return string the HTML for a preview question icon.


 */

< function quiz_question_preview_button($quiz, $question, $label = false, $variant = null) {



> function quiz_question_preview_button($quiz, $question, $label = false, $variant = null, $random = null) {


    global $PAGE;
    if (!question_has_capability_on($question, 'use')) {
        return '';
    }

< 
<     return $PAGE->get_renderer('mod_quiz', 'edit')->question_preview_icon($quiz, $question, $label, $variant);



>     $structure = quiz_settings::create($quiz->id)->get_structure();
>     if (!empty($question->slot)) {
>         $requestedversion = $structure->get_slot_by_number($question->slot)->requestedversion
>                 ?? question_preview_options::ALWAYS_LATEST;
>     } else {
>         $requestedversion = question_preview_options::ALWAYS_LATEST;
>     }
>     return $PAGE->get_renderer('mod_quiz', 'edit')->question_preview_icon(
>             $quiz, $question, $label, $variant, $requestedversion);


}

/**

<  * @param object $attempt the attempt.
<  * @param object $context the quiz context.



>  * @param stdClass $attempt the attempt.
>  * @param stdClass $context the quiz context.


 * @return int whether flags should be shown/editable to the current user for this attempt.
 */
function quiz_get_flag_option($attempt, $context) {
    global $USER;
    if (!has_capability('moodle/question:flag', $context)) {
        return question_display_options::HIDDEN;
    } else if ($attempt->userid == $USER->id) {
        return question_display_options::EDITABLE;
    } else {
        return question_display_options::VISIBLE;
    }
}

/**
 * Work out what state this quiz attempt is in - in the sense used by
 * quiz_get_review_options, not in the sense of $attempt->state.

<  * @param object $quiz the quiz settings
<  * @param object $attempt the quiz_attempt database row.
<  * @return int one of the mod_quiz_display_options::DURING,



>  * @param stdClass $quiz the quiz settings
>  * @param stdClass $attempt the quiz_attempt database row.
>  * @return int one of the display_options::DURING,


 *      IMMEDIATELY_AFTER, LATER_WHILE_OPEN or AFTER_CLOSE constants.
 */
function quiz_attempt_state($quiz, $attempt) {
    if ($attempt->state == quiz_attempt::IN_PROGRESS) {

<         return mod_quiz_display_options::DURING;



>         return display_options::DURING;


    } else if ($quiz->timeclose && time() >= $quiz->timeclose) {

<         return mod_quiz_display_options::AFTER_CLOSE;



>         return display_options::AFTER_CLOSE;


    } else if (time() < $attempt->timefinish + 120) {

<         return mod_quiz_display_options::IMMEDIATELY_AFTER;



>         return display_options::IMMEDIATELY_AFTER;


    } else {

<         return mod_quiz_display_options::LATER_WHILE_OPEN;



>         return display_options::LATER_WHILE_OPEN;


    }
}

/**

<  * The the appropraite mod_quiz_display_options object for this attempt at this
<  * quiz right now.



>  * The appropriate display_options object for this attempt at this quiz right now.


 *
 * @param stdClass $quiz the quiz instance.
 * @param stdClass $attempt the attempt in question.
 * @param context $context the quiz context.
 *

<  * @return mod_quiz_display_options



>  * @return display_options


 */
function quiz_get_review_options($quiz, $attempt, $context) {

<     $options = mod_quiz_display_options::make_from_quiz($quiz, quiz_attempt_state($quiz, $attempt));



>     $options = display_options::make_from_quiz($quiz, quiz_attempt_state($quiz, $attempt));



    $options->readonly = true;
    $options->flags = quiz_get_flag_option($attempt, $context);
    if (!empty($attempt->id)) {
        $options->questionreviewlink = new moodle_url('/mod/quiz/reviewquestion.php',

<                 array('attempt' => $attempt->id));



>                 ['attempt' => $attempt->id]);


    }

    // Show a link to the comment box only for closed attempts.
    if (!empty($attempt->id) && $attempt->state == quiz_attempt::FINISHED && !$attempt->preview &&
            !is_null($context) && has_capability('mod/quiz:grade', $context)) {
        $options->manualcomment = question_display_options::VISIBLE;
        $options->manualcommentlink = new moodle_url('/mod/quiz/comment.php',

<                 array('attempt' => $attempt->id));



>                 ['attempt' => $attempt->id]);


    }

    if (!is_null($context) && !$attempt->preview &&
            has_capability('mod/quiz:viewreports', $context) &&
            has_capability('moodle/grade:viewhidden', $context)) {
        // People who can see reports and hidden grades should be shown everything,
        // except during preview when teachers want to see what students see.
        $options->attempt = question_display_options::VISIBLE;
        $options->correctness = question_display_options::VISIBLE;
        $options->marks = question_display_options::MARK_AND_MAX;
        $options->feedback = question_display_options::VISIBLE;
        $options->numpartscorrect = question_display_options::VISIBLE;
        $options->manualcomment = question_display_options::VISIBLE;
        $options->generalfeedback = question_display_options::VISIBLE;
        $options->rightanswer = question_display_options::VISIBLE;
        $options->overallfeedback = question_display_options::VISIBLE;
        $options->history = question_display_options::VISIBLE;

>         $options->userinfoinhistory = $attempt->userid;



    }

    return $options;
}

/**
 * Combines the review options from a number of different quiz attempts.
 * Returns an array of two ojects, so the suggested way of calling this
 * funciton is:
 * list($someoptions, $alloptions) = quiz_get_combined_reviewoptions(...)
 *

<  * @param object $quiz the quiz instance.



>  * @param stdClass $quiz the quiz instance.


 * @param array $attempts an array of attempt objects.
 *
 * @return array of two options objects, one showing which options are true for
 *          at least one of the attempts, the other showing which options are true
 *          for all attempts.
 */
function quiz_get_combined_reviewoptions($quiz, $attempts) {

<     $fields = array('feedback', 'generalfeedback', 'rightanswer', 'overallfeedback');



>     $fields = ['feedback', 'generalfeedback', 'rightanswer', 'overallfeedback'];


    $someoptions = new stdClass();
    $alloptions = new stdClass();
    foreach ($fields as $field) {
        $someoptions->$field = false;
        $alloptions->$field = true;
    }
    $someoptions->marks = question_display_options::HIDDEN;
    $alloptions->marks = question_display_options::MARK_AND_MAX;

    // This shouldn't happen, but we need to prevent reveal information.
    if (empty($attempts)) {

<         return array($someoptions, $someoptions);



>         return [$someoptions, $someoptions];


    }

    foreach ($attempts as $attempt) {

<         $attemptoptions = mod_quiz_display_options::make_from_quiz($quiz,



>         $attemptoptions = display_options::make_from_quiz($quiz,


                quiz_attempt_state($quiz, $attempt));
        foreach ($fields as $field) {
            $someoptions->$field = $someoptions->$field || $attemptoptions->$field;
            $alloptions->$field = $alloptions->$field && $attemptoptions->$field;
        }
        $someoptions->marks = max($someoptions->marks, $attemptoptions->marks);
        $alloptions->marks = min($alloptions->marks, $attemptoptions->marks);
    }

<     return array($someoptions, $alloptions);



>     return [$someoptions, $alloptions];


}

// Functions for sending notification messages /////////////////////////////////

/**
 * Sends a confirmation message to the student confirming that the attempt was processed.
 *

<  * @param object $a lots of useful information that can be used in the message



>  * @param stdClass $recipient user object for the recipient.
>  * @param stdClass $a lots of useful information that can be used in the message


 *      subject and body.

>  * @param bool $studentisonline is the student currently interacting with Moodle?


 *
 * @return int|false as for {@link message_send()}.
 */

< function quiz_send_confirmation($recipient, $a) {



> function quiz_send_confirmation($recipient, $a, $studentisonline) {



    // Add information about the recipient to $a.
    // Don't do idnumber. we want idnumber to be the submitter's idnumber.
    $a->username     = fullname($recipient);
    $a->userusername = $recipient->username;

    // Prepare the message.
    $eventdata = new \core\message\message();
    $eventdata->courseid          = $a->courseid;
    $eventdata->component         = 'mod_quiz';
    $eventdata->name              = 'confirmation';
    $eventdata->notification      = 1;

    $eventdata->userfrom          = core_user::get_noreply_user();
    $eventdata->userto            = $recipient;
    $eventdata->subject           = get_string('emailconfirmsubject', 'quiz', $a);

> 
    $eventdata->fullmessage       = get_string('emailconfirmbody', 'quiz', $a);
>     if ($studentisonline) {


    $eventdata->fullmessageformat = FORMAT_PLAIN;

>     } else {
    $eventdata->fullmessagehtml   = '';
>         $eventdata->fullmessage = get_string('emailconfirmbodyautosubmit', 'quiz', $a);

>     }
    $eventdata->smallmessage      = get_string('emailconfirmsmall', 'quiz', $a);
> 


    $eventdata->contexturl        = $a->quizurl;
    $eventdata->contexturlname    = $a->quizname;
    $eventdata->customdata        = [
        'cmid' => $a->quizcmid,
        'instance' => $a->quizid,
        'attemptid' => $a->attemptid,
    ];

    // ... and send it.
    return message_send($eventdata);
}

/**
 * Sends notification messages to the interested parties that assign the role capability
 *

<  * @param object $recipient user object of the intended recipient
<  * @param object $a associative array of replaceable fields for the templates



>  * @param stdClass $recipient user object of the intended recipient
>  * @param stdClass $submitter user object for the user who submitted the attempt.
>  * @param stdClass $a associative array of replaceable fields for the templates


 *
 * @return int|false as for {@link message_send()}.
 */
function quiz_send_notification($recipient, $submitter, $a) {
    global $PAGE;

    // Recipient info for template.
    $a->useridnumber = $recipient->idnumber;
    $a->username     = fullname($recipient);
    $a->userusername = $recipient->username;

    // Prepare the message.
    $eventdata = new \core\message\message();
    $eventdata->courseid          = $a->courseid;
    $eventdata->component         = 'mod_quiz';
    $eventdata->name              = 'submission';
    $eventdata->notification      = 1;

    $eventdata->userfrom          = $submitter;
    $eventdata->userto            = $recipient;
    $eventdata->subject           = get_string('emailnotifysubject', 'quiz', $a);
    $eventdata->fullmessage       = get_string('emailnotifybody', 'quiz', $a);
    $eventdata->fullmessageformat = FORMAT_PLAIN;
    $eventdata->fullmessagehtml   = '';

    $eventdata->smallmessage      = get_string('emailnotifysmall', 'quiz', $a);
    $eventdata->contexturl        = $a->quizreviewurl;
    $eventdata->contexturlname    = $a->quizname;
    $userpicture = new user_picture($submitter);
    $userpicture->size = 1; // Use f1 size.
    $userpicture->includetoken = $recipient->id; // Generate an out-of-session token for the user receiving the message.
    $eventdata->customdata        = [
        'cmid' => $a->quizcmid,
        'instance' => $a->quizid,
        'attemptid' => $a->attemptid,
        'notificationiconurl' => $userpicture->get_url($PAGE)->out(false),
    ];

    // ... and send it.
    return message_send($eventdata);
}

/**
 * Send all the requried messages when a quiz attempt is submitted.
 *

<  * @param object $course the course
<  * @param object $quiz the quiz
<  * @param object $attempt this attempt just finished
<  * @param object $context the quiz context
<  * @param object $cm the coursemodule for this quiz



>  * @param stdClass $course the course
>  * @param stdClass $quiz the quiz
>  * @param stdClass $attempt this attempt just finished
>  * @param stdClass $context the quiz context
>  * @param stdClass $cm the coursemodule for this quiz
>  * @param bool $studentisonline is the student currently interacting with Moodle?


 *
 * @return bool true if all necessary messages were sent successfully, else false.
 */

< function quiz_send_notification_messages($course, $quiz, $attempt, $context, $cm) {



> function quiz_send_notification_messages($course, $quiz, $attempt, $context, $cm, $studentisonline) {


    global $CFG, $DB;

    // Do nothing if required objects not present.
    if (empty($course) or empty($quiz) or empty($attempt) or empty($context)) {
        throw new coding_exception('$course, $quiz, $attempt, $context and $cm must all be set.');
    }


<     $submitter = $DB->get_record('user', array('id' => $attempt->userid), '*', MUST_EXIST);



>     $submitter = $DB->get_record('user', ['id' => $attempt->userid], '*', MUST_EXIST);



    // Check for confirmation required.
    $sendconfirm = false;
    $notifyexcludeusers = '';
    if (has_capability('mod/quiz:emailconfirmsubmission', $context, $submitter, false)) {
        $notifyexcludeusers = $submitter->id;
        $sendconfirm = true;
    }

    // Check for notifications required.
    $notifyfields = 'u.id, u.username, u.idnumber, u.email, u.emailstop, u.lang,
            u.timezone, u.mailformat, u.maildisplay, u.auth, u.suspended, u.deleted, ';

<     $notifyfields .= get_all_user_name_fields(true, 'u');



>     $userfieldsapi = \core_user\fields::for_name();
>     $notifyfields .= $userfieldsapi->get_sql('u', false, '', '', false)->selects;


    $groups = groups_get_all_groups($course->id, $submitter->id, $cm->groupingid);
    if (is_array($groups) && count($groups) > 0) {
        $groups = array_keys($groups);
    } else if (groups_get_activity_groupmode($cm, $course) != NOGROUPS) {
        // If the user is not in a group, and the quiz is set to group mode,
        // then set $groups to a non-existant id so that only users with
        // 'moodle/site:accessallgroups' get notified.
        $groups = -1;
    } else {
        $groups = '';
    }
    $userstonotify = get_users_by_capability($context, 'mod/quiz:emailnotifysubmission',
            $notifyfields, '', '', '', $groups, $notifyexcludeusers, false, false, true);

    if (empty($userstonotify) && !$sendconfirm) {
        return true; // Nothing to do.
    }

    $a = new stdClass();
    // Course info.
    $a->courseid        = $course->id;
    $a->coursename      = $course->fullname;
    $a->courseshortname = $course->shortname;
    // Quiz info.
    $a->quizname        = $quiz->name;
    $a->quizreporturl   = $CFG->wwwroot . '/mod/quiz/report.php?id=' . $cm->id;
    $a->quizreportlink  = '<a href="' . $a->quizreporturl . '">' .
            format_string($quiz->name) . ' report</a>';
    $a->quizurl         = $CFG->wwwroot . '/mod/quiz/view.php?id=' . $cm->id;
    $a->quizlink        = '<a href="' . $a->quizurl . '">' . format_string($quiz->name) . '</a>';
    $a->quizid          = $quiz->id;
    $a->quizcmid        = $cm->id;
    // Attempt info.
    $a->submissiontime  = userdate($attempt->timefinish);
    $a->timetaken       = format_time($attempt->timefinish - $attempt->timestart);
    $a->quizreviewurl   = $CFG->wwwroot . '/mod/quiz/review.php?attempt=' . $attempt->id;
    $a->quizreviewlink  = '<a href="' . $a->quizreviewurl . '">' .
            format_string($quiz->name) . ' review</a>';
    $a->attemptid       = $attempt->id;
    // Student who sat the quiz info.
    $a->studentidnumber = $submitter->idnumber;
    $a->studentname     = fullname($submitter);
    $a->studentusername = $submitter->username;

    $allok = true;

    // Send notifications if required.
    if (!empty($userstonotify)) {
        foreach ($userstonotify as $recipient) {
            $allok = $allok && quiz_send_notification($recipient, $submitter, $a);
        }
    }

    // Send confirmation if required. We send the student confirmation last, so
    // that if message sending is being intermittently buggy, which means we send
    // some but not all messages, and then try again later, then teachers may get
    // duplicate messages, but the student will always get exactly one.
    if ($sendconfirm) {

<         $allok = $allok && quiz_send_confirmation($submitter, $a);



>         $allok = $allok && quiz_send_confirmation($submitter, $a, $studentisonline);


    }

    return $allok;
}

/**
 * Send the notification message when a quiz attempt becomes overdue.
 *
 * @param quiz_attempt $attemptobj all the data about the quiz attempt.
 */
function quiz_send_overdue_message($attemptobj) {
    global $CFG, $DB;


<     $submitter = $DB->get_record('user', array('id' => $attemptobj->get_userid()), '*', MUST_EXIST);



>     $submitter = $DB->get_record('user', ['id' => $attemptobj->get_userid()], '*', MUST_EXIST);



    if (!$attemptobj->has_capability('mod/quiz:emailwarnoverdue', $submitter->id, false)) {
        return; // Message not required.
    }

    if (!$attemptobj->has_response_to_at_least_one_graded_question()) {
        return; // Message not required.
    }

    // Prepare lots of useful information that admins might want to include in
    // the email message.
    $quizname = format_string($attemptobj->get_quiz_name());


<     $deadlines = array();



>     $deadlines = [];


    if ($attemptobj->get_quiz()->timelimit) {
        $deadlines[] = $attemptobj->get_attempt()->timestart + $attemptobj->get_quiz()->timelimit;
    }
    if ($attemptobj->get_quiz()->timeclose) {
        $deadlines[] = $attemptobj->get_quiz()->timeclose;
    }
    $duedate = min($deadlines);
    $graceend = $duedate + $attemptobj->get_quiz()->graceperiod;

    $a = new stdClass();
    // Course info.
    $a->courseid           = $attemptobj->get_course()->id;
    $a->coursename         = format_string($attemptobj->get_course()->fullname);
    $a->courseshortname    = format_string($attemptobj->get_course()->shortname);
    // Quiz info.
    $a->quizname           = $quizname;

<     $a->quizurl            = $attemptobj->view_url();



>     $a->quizurl            = $attemptobj->view_url()->out(false);


    $a->quizlink           = '<a href="' . $a->quizurl . '">' . $quizname . '</a>';
    // Attempt info.
    $a->attemptduedate     = userdate($duedate);
    $a->attemptgraceend    = userdate($graceend);
    $a->attemptsummaryurl  = $attemptobj->summary_url()->out(false);
    $a->attemptsummarylink = '<a href="' . $a->attemptsummaryurl . '">' . $quizname . ' review</a>';
    // Student's info.
    $a->studentidnumber    = $submitter->idnumber;
    $a->studentname        = fullname($submitter);
    $a->studentusername    = $submitter->username;

    // Prepare the message.
    $eventdata = new \core\message\message();
    $eventdata->courseid          = $a->courseid;
    $eventdata->component         = 'mod_quiz';
    $eventdata->name              = 'attempt_overdue';
    $eventdata->notification      = 1;

    $eventdata->userfrom          = core_user::get_noreply_user();
    $eventdata->userto            = $submitter;
    $eventdata->subject           = get_string('emailoverduesubject', 'quiz', $a);
    $eventdata->fullmessage       = get_string('emailoverduebody', 'quiz', $a);
    $eventdata->fullmessageformat = FORMAT_PLAIN;
    $eventdata->fullmessagehtml   = '';

    $eventdata->smallmessage      = get_string('emailoverduesmall', 'quiz', $a);
    $eventdata->contexturl        = $a->quizurl;
    $eventdata->contexturlname    = $a->quizname;
    $eventdata->customdata        = [
        'cmid' => $attemptobj->get_cmid(),
        'instance' => $attemptobj->get_quizid(),
        'attemptid' => $attemptobj->get_attemptid(),
    ];

    // Send the message.
    return message_send($eventdata);
}

/**
 * Handle the quiz_attempt_submitted event.
 *
 * This sends the confirmation and notification messages, if required.
 *

<  * @param object $event the event object.



>  * @param attempt_submitted $event the event object.


 */
function quiz_attempt_submitted_handler($event) {

<     global $DB;
< 
<     $course  = $DB->get_record('course', array('id' => $event->courseid));



>     $course = get_course($event->courseid);


    $attempt = $event->get_record_snapshot('quiz_attempts', $event->objectid);
    $quiz    = $event->get_record_snapshot('quiz', $attempt->quiz);
    $cm      = get_coursemodule_from_id('quiz', $event->get_context()->instanceid, $event->courseid);

>     $eventdata = $event->get_data();



    if (!($course && $quiz && $cm && $attempt)) {
        // Something has been deleted since the event was raised. Therefore, the
        // event is no longer relevant.
        return true;
    }

    // Update completion state.
    $completion = new completion_info($course);
    if ($completion->is_enabled($cm) &&

<         ($quiz->completionattemptsexhausted || $quiz->completionpass || $quiz->completionminattempts)) {



>         ($quiz->completionattemptsexhausted || $quiz->completionminattempts)) {


        $completion->update_state($cm, COMPLETION_COMPLETE, $event->userid);
    }
    return quiz_send_notification_messages($course, $quiz, $attempt,

<             context_module::instance($cm->id), $cm);



>             context_module::instance($cm->id), $cm, $eventdata['other']['studentisonline']);


}

/**

<  * Handle groups_member_added event



>  * Send the notification message when a quiz attempt has been manual graded.


 *

<  * @param object $event the event object.
<  * @deprecated since 2.6, see {@link \mod_quiz\group_observers::group_member_added()}.



>  * @param quiz_attempt $attemptobj Some data about the quiz attempt.
>  * @param stdClass $userto
>  * @return int|false As for message_send.


 */

< function quiz_groups_member_added_handler($event) {
<     debugging('quiz_groups_member_added_handler() is deprecated, please use ' .
<         '\mod_quiz\group_observers::group_member_added() instead.', DEBUG_DEVELOPER);
<     quiz_update_open_attempts(array('userid'=>$event->userid, 'groupid'=>$event->groupid));
< }



> function quiz_send_notify_manual_graded_message(quiz_attempt $attemptobj, object $userto): ?int {
>     global $CFG;




< /**
<  * Handle groups_member_removed event
<  *
<  * @param object $event the event object.
<  * @deprecated since 2.6, see {@link \mod_quiz\group_observers::group_member_removed()}.
<  */
< function quiz_groups_member_removed_handler($event) {
<     debugging('quiz_groups_member_removed_handler() is deprecated, please use ' .
<         '\mod_quiz\group_observers::group_member_removed() instead.', DEBUG_DEVELOPER);
<     quiz_update_open_attempts(array('userid'=>$event->userid, 'groupid'=>$event->groupid));
< }



>     $quizname = format_string($attemptobj->get_quiz_name());




< /**
<  * Handle groups_group_deleted event
<  *
<  * @param object $event the event object.
<  * @deprecated since 2.6, see {@link \mod_quiz\group_observers::group_deleted()}.
<  */
< function quiz_groups_group_deleted_handler($event) {
<     global $DB;
<     debugging('quiz_groups_group_deleted_handler() is deprecated, please use ' .
<         '\mod_quiz\group_observers::group_deleted() instead.', DEBUG_DEVELOPER);
<     quiz_process_group_deleted_in_course($event->courseid);



>     $a = new stdClass();
>     // Course info.
>     $a->courseid           = $attemptobj->get_courseid();
>     $a->coursename         = format_string($attemptobj->get_course()->fullname);
>     // Quiz info.
>     $a->quizname           = $quizname;
>     $a->quizurl            = $CFG->wwwroot . '/mod/quiz/view.php?id=' . $attemptobj->get_cmid();
> 
>     // Attempt info.
>     $a->attempttimefinish  = userdate($attemptobj->get_attempt()->timefinish);
>     // Student's info.
>     $a->studentidnumber    = $userto->idnumber;
>     $a->studentname        = fullname($userto);
> 
>     $eventdata = new \core\message\message();
>     $eventdata->component = 'mod_quiz';
>     $eventdata->name = 'attempt_grading_complete';
>     $eventdata->userfrom = core_user::get_noreply_user();
>     $eventdata->userto = $userto;
> 
>     $eventdata->subject = get_string('emailmanualgradedsubject', 'quiz', $a);
>     $eventdata->fullmessage = get_string('emailmanualgradedbody', 'quiz', $a);
>     $eventdata->fullmessageformat = FORMAT_PLAIN;
>     $eventdata->fullmessagehtml = '';
> 
>     $eventdata->notification = 1;
>     $eventdata->contexturl = $a->quizurl;
>     $eventdata->contexturlname = $a->quizname;
> 
>     // Send the message.
>     return message_send($eventdata);


}


> 


/**
 * Logic to happen when a/some group(s) has/have been deleted in a course.
 *
 * @param int $courseid The course ID.
 * @return void
 */
function quiz_process_group_deleted_in_course($courseid) {
    global $DB;

    // It would be nice if we got the groupid that was deleted.
    // Instead, we just update all quizzes with orphaned group overrides.

<     $sql = "SELECT o.id, o.quiz



>     $sql = "SELECT o.id, o.quiz, o.groupid


              FROM {quiz_overrides} o
              JOIN {quiz} quiz ON quiz.id = o.quiz
         LEFT JOIN {groups} grp ON grp.id = o.groupid
             WHERE quiz.course = :courseid
               AND o.groupid IS NOT NULL
               AND grp.id IS NULL";

<     $params = array('courseid' => $courseid);
<     $records = $DB->get_records_sql_menu($sql, $params);



>     $params = ['courseid' => $courseid];
>     $records = $DB->get_records_sql($sql, $params);


    if (!$records) {
        return; // Nothing to do.
    }
    $DB->delete_records_list('quiz_overrides', 'id', array_keys($records));

<     quiz_update_open_attempts(array('quizid' => array_unique(array_values($records))));
< }
< 
< /**
<  * Handle groups_members_removed event
<  *
<  * @param object $event the event object.
<  * @deprecated since 2.6, see {@link \mod_quiz\group_observers::group_member_removed()}.
<  */
< function quiz_groups_members_removed_handler($event) {
<     debugging('quiz_groups_members_removed_handler() is deprecated, please use ' .
<         '\mod_quiz\group_observers::group_member_removed() instead.', DEBUG_DEVELOPER);
<     if ($event->userid == 0) {
<         quiz_update_open_attempts(array('courseid'=>$event->courseid));
<     } else {
<         quiz_update_open_attempts(array('courseid'=>$event->courseid, 'userid'=>$event->userid));



>     $cache = cache::make('mod_quiz', 'overrides');
>     foreach ($records as $record) {
>         $cache->delete("{$record->quiz}_g_{$record->groupid}");


    }

>     quiz_update_open_attempts(['quizid' => array_unique(array_column($records, 'quiz'))]);


}

/**
 * Get the information about the standard quiz JavaScript module.
 * @return array a standard jsmodule structure.
 */
function quiz_get_js_module() {
    global $PAGE;


<     return array(



>     return [


        'name' => 'mod_quiz',
        'fullpath' => '/mod/quiz/module.js',

<         'requires' => array('base', 'dom', 'event-delegate', 'event-key',
<                 'core_question_engine', 'moodle-core-formchangechecker'),
<         'strings' => array(
<             array('cancel', 'moodle'),
<             array('flagged', 'question'),
<             array('functiondisabledbysecuremode', 'quiz'),
<             array('startattempt', 'quiz'),
<             array('timesup', 'quiz'),
<             array('changesmadereallygoaway', 'moodle'),
<         ),
<     );
< }
< 
< 
< /**
<  * An extension of question_display_options that includes the extra options used
<  * by the quiz.
<  *
<  * @copyright  2010 The Open University
<  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
<  */
< class mod_quiz_display_options extends question_display_options {
<     /**#@+
<      * @var integer bits used to indicate various times in relation to a
<      * quiz attempt.
<      */
<     const DURING =            0x10000;
<     const IMMEDIATELY_AFTER = 0x01000;
<     const LATER_WHILE_OPEN =  0x00100;
<     const AFTER_CLOSE =       0x00010;
<     /**#@-*/
< 
<     /**
<      * @var boolean if this is false, then the student is not allowed to review
<      * anything about the attempt.
<      */
<     public $attempt = true;
< 
<     /**
<      * @var boolean if this is false, then the student is not allowed to review
<      * anything about the attempt.
<      */
<     public $overallfeedback = self::VISIBLE;
< 
<     /**
<      * Set up the various options from the quiz settings, and a time constant.
<      * @param object $quiz the quiz settings.
<      * @param int $one of the {@link DURING}, {@link IMMEDIATELY_AFTER},
<      * {@link LATER_WHILE_OPEN} or {@link AFTER_CLOSE} constants.
<      * @return mod_quiz_display_options set up appropriately.
<      */
<     public static function make_from_quiz($quiz, $when) {
<         $options = new self();
< 
<         $options->attempt = self::extract($quiz->reviewattempt, $when, true, false);
<         $options->correctness = self::extract($quiz->reviewcorrectness, $when);
<         $options->marks = self::extract($quiz->reviewmarks, $when,
<                 self::MARK_AND_MAX, self::MAX_ONLY);
<         $options->feedback = self::extract($quiz->reviewspecificfeedback, $when);
<         $options->generalfeedback = self::extract($quiz->reviewgeneralfeedback, $when);
<         $options->rightanswer = self::extract($quiz->reviewrightanswer, $when);
<         $options->overallfeedback = self::extract($quiz->reviewoverallfeedback, $when);
< 
<         $options->numpartscorrect = $options->feedback;
<         $options->manualcomment = $options->feedback;
< 
<         if ($quiz->questiondecimalpoints != -1) {
<             $options->markdp = $quiz->questiondecimalpoints;
<         } else {
<             $options->markdp = $quiz->decimalpoints;
<         }
< 
<         return $options;
<     }
< 
<     protected static function extract($bitmask, $bit,
<             $whenset = self::VISIBLE, $whennotset = self::HIDDEN) {
<         if ($bitmask & $bit) {
<             return $whenset;
<         } else {
<             return $whennotset;
<         }
<     }
< }
< 
< /**
<  * A {@link qubaid_condition} for finding all the question usages belonging to
<  * a particular quiz.
<  *
<  * @copyright  2010 The Open University
<  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
<  */
< class qubaids_for_quiz extends qubaid_join {
<     public function __construct($quizid, $includepreviews = true, $onlyfinished = false) {
<         $where = 'quiza.quiz = :quizaquiz';
<         $params = array('quizaquiz' => $quizid);
< 
<         if (!$includepreviews) {
<             $where .= ' AND preview = 0';
<         }
< 
<         if ($onlyfinished) {
<             $where .= ' AND state = :statefinished';
<             $params['statefinished'] = quiz_attempt::FINISHED;
<         }
< 
<         parent::__construct('{quiz_attempts} quiza', 'quiza.uniqueid', $where, $params);
<     }
< }
< 
< /**
<  * A {@link qubaid_condition} for finding all the question usages belonging to a particular user and quiz combination.
<  *
<  * @copyright  2018 Andrew Nicols <andrwe@nicols.co.uk>
<  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
<  */
< class qubaids_for_quiz_user extends qubaid_join {
<     /**
<      * Constructor for this qubaid.
<      *
<      * @param   int     $quizid The quiz to search.
<      * @param   int     $userid The user to filter on
<      * @param   bool    $includepreviews Whether to include preview attempts
<      * @param   bool    $onlyfinished Whether to only include finished attempts or not
<      */
<     public function __construct($quizid, $userid, $includepreviews = true, $onlyfinished = false) {
<         $where = 'quiza.quiz = :quizaquiz AND quiza.userid = :quizauserid';
<         $params = [
<             'quizaquiz' => $quizid,
<             'quizauserid' => $userid,



>         'requires' => ['base', 'dom', 'event-delegate', 'event-key',
>                 'core_question_engine'],
>         'strings' => [
>             ['cancel', 'moodle'],
>             ['flagged', 'question'],
>             ['functiondisabledbysecuremode', 'quiz'],
>             ['startattempt', 'quiz'],
>             ['timesup', 'quiz'],
>         ],


        ];

< 
<         if (!$includepreviews) {
<             $where .= ' AND preview = 0';
<         }
< 
<         if ($onlyfinished) {
<             $where .= ' AND state = :statefinished';
<             $params['statefinished'] = quiz_attempt::FINISHED;


        }


<         parent::__construct('{quiz_attempts} quiza', 'quiza.uniqueid', $where, $params);
<     }
< }



/**
 * Creates a textual representation of a question for display.
 *

<  * @param object $question A question object from the database questions table



>  * @param stdClass $question A question object from the database questions table


 * @param bool $showicon If true, show the question's icon with the question. False by default.
 * @param bool $showquestiontext If true (default), show question text after question name.
 *       If false, show only question name.
 * @param bool $showidnumber If true, show the question's idnumber, if any. False by default.
 * @param core_tag_tag[]|bool $showtags if array passed, show those tags. Else, if true, get and show tags,
 *       else, don't show tags (which is the default).
 * @return string HTML fragment.
 */
function quiz_question_tostring($question, $showicon = false, $showquestiontext = true,
        $showidnumber = false, $showtags = false) {
    global $OUTPUT;
    $result = '';

    // Question name.
    $name = shorten_text(format_string($question->name), 200);
    if ($showicon) {
        $name .= print_question_icon($question) . ' ' . $name;
    }
    $result .= html_writer::span($name, 'questionname');

    // Question idnumber.
    if ($showidnumber && $question->idnumber !== null && $question->idnumber !== '') {
        $result .= ' ' . html_writer::span(
                html_writer::span(get_string('idnumber', 'question'), 'accesshide') .
                ' ' . s($question->idnumber), 'badge badge-primary');
    }

    // Question tags.
    if (is_array($showtags)) {
        $tags = $showtags;
    } else if ($showtags) {
        $tags = core_tag_tag::get_item_tags('core_question', 'question', $question->id);
    } else {
        $tags = [];
    }
    if ($tags) {
        $result .= $OUTPUT->tag_list($tags, null, 'd-inline', 0, null, true);
    }

    // Question text.
    if ($showquestiontext) {
        $questiontext = question_utils::to_plain_text($question->questiontext,

<                 $question->questiontextformat, array('noclean' => true, 'para' => false));
<         $questiontext = shorten_text($questiontext, 200);



>                 $question->questiontextformat, ['noclean' => true, 'para' => false, 'filter' => false]);
>         $questiontext = shorten_text($questiontext, 50);


        if ($questiontext) {
            $result .= ' ' . html_writer::span(s($questiontext), 'questiontext');
        }
    }

    return $result;
}

/**
 * Verify that the question exists, and the user has permission to use it.
 * Does not return. Throws an exception if the question cannot be used.
 * @param int $questionid The id of the question.
 */
function quiz_require_question_use($questionid) {
    global $DB;

<     $question = $DB->get_record('question', array('id' => $questionid), '*', MUST_EXIST);



>     $question = $DB->get_record('question', ['id' => $questionid], '*', MUST_EXIST);


    question_require_capability_on($question, 'use');
}

/**

<  * Verify that the question exists, and the user has permission to use it.
<  * @param object $quiz the quiz settings.
<  * @param int $slot which question in the quiz to test.
<  * @return bool whether the user can use this question.
<  */
< function quiz_has_question_use($quiz, $slot) {
<     global $DB;
<     $question = $DB->get_record_sql("
<             SELECT q.*
<               FROM {quiz_slots} slot
<               JOIN {question} q ON q.id = slot.questionid
<              WHERE slot.quizid = ? AND slot.slot = ?", array($quiz->id, $slot));
<     if (!$question) {
<         return false;
<     }
<     return question_has_capability_on($question, 'use');
< }
< 
< /**


 * Add a question to a quiz
 *
 * Adds a question to a quiz by updating $quiz as well as the
 * quiz and quiz_slots tables. It also adds a page break if required.
 * @param int $questionid The id of the question to be added

<  * @param object $quiz The extended quiz object as used by edit.php



>  * @param stdClass $quiz The extended quiz object as used by edit.php


 *      This is updated by this function
 * @param int $page Which page in quiz to add the question on. If 0 (default),
 *      add at the end
 * @param float $maxmark The maximum mark to set for this question. (Optional,
 *      defaults to question.defaultmark.
 * @return bool false if the question was already in the quiz
 */
function quiz_add_quiz_question($questionid, $quiz, $page = 0, $maxmark = null) {
    global $DB;


>     if (!isset($quiz->cmid)) {
    // Make sue the question is not of the "random" type.
>         $cm = get_coursemodule_from_instance('quiz', $quiz->id, $quiz->course);
    $questiontype = $DB->get_field('question', 'qtype', array('id' => $questionid));
>         $quiz->cmid = $cm->id;
    if ($questiontype == 'random') {
>     }
        throw new coding_exception(
> 



<     $questiontype = $DB->get_field('question', 'qtype', array('id' => $questionid));



>     $questiontype = $DB->get_field('question', 'qtype', ['id' => $questionid]);


        );
    }

    $trans = $DB->start_delegated_transaction();

<     $slots = $DB->get_records('quiz_slots', array('quizid' => $quiz->id),
<             'slot', 'questionid, slot, page, id');
<     if (array_key_exists($questionid, $slots)) {



> 
>     $sql = "SELECT qbe.id
>               FROM {quiz_slots} slot
>               JOIN {question_references} qr ON qr.itemid = slot.id
>               JOIN {question_bank_entries} qbe ON qbe.id = qr.questionbankentryid
>              WHERE slot.quizid = ?
>                AND qr.component = ?
>                AND qr.questionarea = ?
>                AND qr.usingcontextid = ?";
> 
>     $questionslots = $DB->get_records_sql($sql, [$quiz->id, 'mod_quiz', 'slot',
>             context_module::instance($quiz->cmid)->id]);
> 
>     $currententry = get_question_bank_entry($questionid);
> 
>     if (array_key_exists($currententry->id, $questionslots)) {


        $trans->allow_commit();
        return false;
    }


>     $sql = "SELECT slot.slot, slot.page, slot.id
    $maxpage = 1;
>               FROM {quiz_slots} slot
    $numonlastpage = 0;
>              WHERE slot.quizid = ?
    foreach ($slots as $slot) {
>           ORDER BY slot.slot";
        if ($slot->page > $maxpage) {
> 
            $maxpage = $slot->page;
>     $slots = $DB->get_records_sql($sql, [$quiz->id]);
            $numonlastpage = 1;
> 


        } else {
            $numonlastpage += 1;
        }
    }


<     // Add the new question instance.



>     // Add the new instance.


    $slot = new stdClass();
    $slot->quizid = $quiz->id;

<     $slot->questionid = $questionid;



    if ($maxmark !== null) {
        $slot->maxmark = $maxmark;
    } else {

<         $slot->maxmark = $DB->get_field('question', 'defaultmark', array('id' => $questionid));



>         $slot->maxmark = $DB->get_field('question', 'defaultmark', ['id' => $questionid]);


    }

    if (is_int($page) && $page >= 1) {
        // Adding on a given page.
        $lastslotbefore = 0;
        foreach (array_reverse($slots) as $otherslot) {
            if ($otherslot->page > $page) {

<                 $DB->set_field('quiz_slots', 'slot', $otherslot->slot + 1, array('id' => $otherslot->id));



>                 $DB->set_field('quiz_slots', 'slot', $otherslot->slot + 1, ['id' => $otherslot->id]);


            } else {
                $lastslotbefore = $otherslot->slot;
                break;
            }
        }
        $slot->slot = $lastslotbefore + 1;
        $slot->page = min($page, $maxpage + 1);

        quiz_update_section_firstslots($quiz->id, 1, max($lastslotbefore, 1));

    } else {
        $lastslot = end($slots);
        if ($lastslot) {
            $slot->slot = $lastslot->slot + 1;
        } else {
            $slot->slot = 1;
        }
        if ($quiz->questionsperpage && $numonlastpage >= $quiz->questionsperpage) {
            $slot->page = $maxpage + 1;
        } else {
            $slot->page = $maxpage;
        }
    }


<     $DB->insert_record('quiz_slots', $slot);



>     $slotid = $DB->insert_record('quiz_slots', $slot);
> 
>     // Update or insert record in question_reference table.
>     $sql = "SELECT DISTINCT qr.id, qr.itemid
>               FROM {question} q
>               JOIN {question_versions} qv ON q.id = qv.questionid
>               JOIN {question_bank_entries} qbe ON qbe.id = qv.questionbankentryid
>               JOIN {question_references} qr ON qbe.id = qr.questionbankentryid AND qr.version = qv.version
>               JOIN {quiz_slots} qs ON qs.id = qr.itemid
>              WHERE q.id = ?
>                AND qs.id = ?
>                AND qr.component = ?
>                AND qr.questionarea = ?";
>     $qreferenceitem = $DB->get_record_sql($sql, [$questionid, $slotid, 'mod_quiz', 'slot']);
> 
>     if (!$qreferenceitem) {
>         // Create a new reference record for questions created already.
>         $questionreferences = new stdClass();
>         $questionreferences->usingcontextid = context_module::instance($quiz->cmid)->id;
>         $questionreferences->component = 'mod_quiz';
>         $questionreferences->questionarea = 'slot';
>         $questionreferences->itemid = $slotid;
>         $questionreferences->questionbankentryid = get_question_bank_entry($questionid)->id;
>         $questionreferences->version = null; // Always latest.
>         $DB->insert_record('question_references', $questionreferences);
> 
>     } else if ($qreferenceitem->itemid === 0 || $qreferenceitem->itemid === null) {
>         $questionreferences = new stdClass();
>         $questionreferences->id = $qreferenceitem->id;
>         $questionreferences->itemid = $slotid;
>         $DB->update_record('question_references', $questionreferences);
>     } else {
>         // If the reference record exits for another quiz.
>         $questionreferences = new stdClass();
>         $questionreferences->usingcontextid = context_module::instance($quiz->cmid)->id;
>         $questionreferences->component = 'mod_quiz';
>         $questionreferences->questionarea = 'slot';
>         $questionreferences->itemid = $slotid;
>         $questionreferences->questionbankentryid = get_question_bank_entry($questionid)->id;
>         $questionreferences->version = null; // Always latest.
>         $DB->insert_record('question_references', $questionreferences);
>     }
> 


    $trans->allow_commit();

> 
}
>     // Log slot created event.

>     $cm = get_coursemodule_from_instance('quiz', $quiz->id);
/**
>     $event = \mod_quiz\event\slot_created::create([
 * Move all the section headings in a certain slot range by a certain offset.
>         'context' => context_module::instance($cm->id),
 *
>         'objectid' => $slotid,
 * @param int $quizid the id of a quiz
>         'other' => [
 * @param int $direction amount to adjust section heading positions. Normally +1 or -1.
>             'quizid' => $quiz->id,
 * @param int $afterslot adjust headings that start after this slot.
>             'slotnumber' => $slot->slot,
 * @param int|null $beforeslot optionally, only adjust headings before this slot.
>             'page' => $slot->page
 */
>         ]
function quiz_update_section_firstslots($quizid, $direction, $afterslot, $beforeslot = null) {
>     ]);
    global $DB;
>     $event->trigger();


    $where = 'quizid = ? AND firstslot > ?';
    $params = [$direction, $quizid, $afterslot];
    if ($beforeslot) {
        $where .= ' AND firstslot < ?';
        $params[] = $beforeslot;
    }
    $firstslotschanges = $DB->get_records_select_menu('quiz_sections',
            $where, $params, '', 'firstslot, firstslot + ?');
    update_field_with_unique_index('quiz_sections', 'firstslot', $firstslotschanges, ['quizid' => $quizid]);
}

/**
 * Add a random question to the quiz at a given point.
 * @param stdClass $quiz the quiz settings.
 * @param int $addonpage the page on which to add the question.
 * @param int $categoryid the question category to add the question from.
 * @param int $number the number of random questions to add.
 * @param bool $includesubcategories whether to include questoins from subcategories.
 * @param int[] $tagids Array of tagids. The question that will be picked randomly should be tagged with all these tags.
 */
function quiz_add_random_questions($quiz, $addonpage, $categoryid, $number,
        $includesubcategories, $tagids = []) {
    global $DB;


<     $category = $DB->get_record('question_categories', array('id' => $categoryid));



>     $category = $DB->get_record('question_categories', ['id' => $categoryid]);


    if (!$category) {

<         print_error('invalidcategoryid', 'error');



>         new moodle_exception('invalidcategoryid');


    }

    $catcontext = context::instance_by_id($category->contextid);
    require_capability('moodle/question:useall', $catcontext);


>     // Tags for filter condition.


    $tags = \core_tag_tag::get_bulk($tagids, 'id, name');
    $tagstrings = [];
    foreach ($tags as $tag) {
        $tagstrings[] = "{$tag->id},{$tag->name}";
    }

< 
<     // Find existing random questions in this category that are
<     // not used by any quiz.
<     $existingquestions = $DB->get_records_sql(
<         "SELECT q.id, q.qtype FROM {question} q
<         WHERE qtype = 'random'
<             AND category = ?
<             AND " . $DB->sql_compare_text('questiontext') . " = ?
<             AND NOT EXISTS (
<                     SELECT *
<                       FROM {quiz_slots}
<                      WHERE questionid = q.id)
<         ORDER BY id", array($category->id, $includesubcategories ? '1' : '0'));
< 



>     // Create the selected number of random questions.


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

<         // Take as many of orphaned "random" questions as needed.
<         if (!$question = array_shift($existingquestions)) {
<             $form = new stdClass();
<             $form->category = $category->id . ',' . $category->contextid;
<             $form->includesubcategories = $includesubcategories;
<             $form->fromtags = $tagstrings;
<             $form->defaultmark = 1;
<             $form->hidden = 1;
<             $form->stamp = make_unique_id_code(); // Set the unique code (not to be changed).
<             $question = new stdClass();
<             $question->qtype = 'random';
<             $question = question_bank::get_qtype('random')->save_question($question, $form);
<             if (!isset($question->id)) {
<                 print_error('cannotinsertrandomquestion', 'quiz');



>         // Set the filter conditions.
>         $filtercondition = new stdClass();
>         $filtercondition->questioncategoryid = $categoryid;
>         $filtercondition->includingsubcategories = $includesubcategories ? 1 : 0;
>         if (!empty($tagstrings)) {
>             $filtercondition->tags = $tagstrings;


            }

> 
        }
>         if (!isset($quiz->cmid)) {

>             $cm = get_coursemodule_from_instance('quiz', $quiz->id, $quiz->course);
        $randomslotdata = new stdClass();
>             $quiz->cmid = $cm->id;


        $randomslotdata->quizid = $quiz->id;

>         // Slot data.



<         $randomslotdata->questionid = $question->id;
<         $randomslotdata->questioncategoryid = $categoryid;
<         $randomslotdata->includingsubcategories = $includesubcategories ? 1 : 0;



>         $randomslotdata->usingcontextid = context_module::instance($quiz->cmid)->id;
>         $randomslotdata->questionscontextid = $category->contextid;


        $randomslotdata->maxmark = 1;

        $randomslot = new \mod_quiz\local\structure\slot_random($randomslotdata);
        $randomslot->set_quiz($quiz);

<         $randomslot->set_tags($tags);



>         $randomslot->set_filter_condition($filtercondition);


        $randomslot->insert($addonpage);
    }
}

/**
 * Mark the activity completed (if required) and trigger the course_module_viewed event.
 *
 * @param  stdClass $quiz       quiz object
 * @param  stdClass $course     course object
 * @param  stdClass $cm         course module object
 * @param  stdClass $context    context object
 * @since Moodle 3.1
 */
function quiz_view($quiz, $course, $cm, $context) {


<     $params = array(



>     $params = [


        'objectid' => $quiz->id,
        'context' => $context

<     );



>     ];



    $event = \mod_quiz\event\course_module_viewed::create($params);
    $event->add_record_snapshot('quiz', $quiz);
    $event->trigger();

    // Completion.
    $completion = new completion_info($course);
    $completion->set_module_viewed($cm);
}

/**
 * Validate permissions for creating a new attempt and start a new preview attempt if required.
 *

<  * @param  quiz $quizobj quiz object
<  * @param  quiz_access_manager $accessmanager quiz access manager



>  * @param  quiz_settings $quizobj quiz object
>  * @param  access_manager $accessmanager quiz access manager


 * @param  bool $forcenew whether was required to start a new preview attempt
 * @param  int $page page to jump to in the attempt
 * @param  bool $redirect whether to redirect or throw exceptions (for web or ws usage)
 * @return array an array containing the attempt information, access error messages and the page to jump to in the attempt

<  * @throws moodle_quiz_exception


 * @since Moodle 3.1
 */

< function quiz_validate_new_attempt(quiz $quizobj, quiz_access_manager $accessmanager, $forcenew, $page, $redirect) {



> function quiz_validate_new_attempt(quiz_settings $quizobj, access_manager $accessmanager, $forcenew, $page, $redirect) {


    global $DB, $USER;
    $timenow = time();

    if ($quizobj->is_preview_user() && $forcenew) {
        $accessmanager->current_attempt_finished();
    }

    // Check capabilities.
    if (!$quizobj->is_preview_user()) {
        $quizobj->require_capability('mod/quiz:attempt');
    }

    // Check to see if a new preview was requested.
    if ($quizobj->is_preview_user() && $forcenew) {
        // To force the creation of a new preview, we mark the current attempt (if any)
        // as abandoned. It will then automatically be deleted below.
        $DB->set_field('quiz_attempts', 'state', quiz_attempt::ABANDONED,

<                 array('quiz' => $quizobj->get_quizid(), 'userid' => $USER->id));



>                 ['quiz' => $quizobj->get_quizid(), 'userid' => $USER->id]);


    }

    // Look for an existing attempt.
    $attempts = quiz_get_user_attempts($quizobj->get_quizid(), $USER->id, 'all', true);
    $lastattempt = end($attempts);

    $attemptnumber = null;
    // If an in-progress attempt exists, check password then redirect to it.
    if ($lastattempt && ($lastattempt->state == quiz_attempt::IN_PROGRESS ||
            $lastattempt->state == quiz_attempt::OVERDUE)) {
        $currentattemptid = $lastattempt->id;
        $messages = $accessmanager->prevent_access();

        // If the attempt is now overdue, deal with that.
        $quizobj->create_attempt_object($lastattempt)->handle_if_time_expired($timenow, true);

        // And, if the attempt is now no longer in progress, redirect to the appropriate place.
        if ($lastattempt->state == quiz_attempt::ABANDONED || $lastattempt->state == quiz_attempt::FINISHED) {
            if ($redirect) {
                redirect($quizobj->review_url($lastattempt->id));
            } else {

<                 throw new moodle_quiz_exception($quizobj, 'attemptalreadyclosed');



>                 throw new moodle_exception('attemptalreadyclosed', 'quiz', $quizobj->view_url());


            }
        }

        // If the page number was not explicitly in the URL, go to the current page.
        if ($page == -1) {
            $page = $lastattempt->currentpage;
        }

    } else {
        while ($lastattempt && $lastattempt->preview) {
            $lastattempt = array_pop($attempts);
        }

        // Get number for the next or unfinished attempt.
        if ($lastattempt) {
            $attemptnumber = $lastattempt->attempt + 1;
        } else {
            $lastattempt = false;
            $attemptnumber = 1;
        }
        $currentattemptid = null;

        $messages = $accessmanager->prevent_access() +
            $accessmanager->prevent_new_attempt(count($attempts), $lastattempt);

        if ($page == -1) {
            $page = 0;
        }
    }

<     return array($currentattemptid, $attemptnumber, $lastattempt, $messages, $page);



>     return [$currentattemptid, $attemptnumber, $lastattempt, $messages, $page];


}

/**
 * Prepare and start a new attempt deleting the previous preview attempts.
 *

<  * @param quiz $quizobj quiz object



>  * @param quiz_settings $quizobj quiz object


 * @param int $attemptnumber the attempt number

<  * @param object $lastattempt last attempt object



>  * @param stdClass $lastattempt last attempt object


 * @param bool $offlineattempt whether is an offline attempt or not
 * @param array $forcedrandomquestions slot number => question id. Used for random questions,
 *      to force the choice of a particular actual question. Intended for testing purposes only.
 * @param array $forcedvariants slot number => variant. Used for questions with variants,
 *      to force the choice of a particular variant. Intended for testing purposes only.
 * @param int $userid Specific user id to create an attempt for that user, null for current logged in user

<  * @return object the new attempt



>  * @return stdClass the new attempt


 * @since  Moodle 3.1
 */

< function quiz_prepare_and_start_new_attempt(quiz $quizobj, $attemptnumber, $lastattempt,



> function quiz_prepare_and_start_new_attempt(quiz_settings $quizobj, $attemptnumber, $lastattempt,


        $offlineattempt = false, $forcedrandomquestions = [], $forcedvariants = [], $userid = null) {
    global $DB, $USER;

    if ($userid === null) {
        $userid = $USER->id;
        $ispreviewuser = $quizobj->is_preview_user();
    } else {
        $ispreviewuser = has_capability('mod/quiz:preview', $quizobj->get_context(), $userid);
    }
    // Delete any previous preview attempts belonging to this user.
    quiz_delete_previews($quizobj->get_quiz(), $userid);

    $quba = question_engine::make_questions_usage_by_activity('mod_quiz', $quizobj->get_context());
    $quba->set_preferred_behaviour($quizobj->get_quiz()->preferredbehaviour);

    // Create the new attempt and initialize the question sessions
    $timenow = time(); // Update time now, in case the server is running really slowly.
    $attempt = quiz_create_attempt($quizobj, $attemptnumber, $lastattempt, $timenow, $ispreviewuser, $userid);

    if (!($quizobj->get_quiz()->attemptonlast && $lastattempt)) {
        $attempt = quiz_start_new_attempt($quizobj, $quba, $attempt, $attemptnumber, $timenow,
                $forcedrandomquestions, $forcedvariants);
    } else {
        $attempt = quiz_start_attempt_built_on_last($quba, $attempt, $lastattempt);
    }

    $transaction = $DB->start_delegated_transaction();

    // Init the timemodifiedoffline for offline attempts.
    if ($offlineattempt) {
        $attempt->timemodifiedoffline = $attempt->timemodified;
    }
    $attempt = quiz_attempt_save_started($quizobj, $quba, $attempt);

    $transaction->allow_commit();

    return $attempt;
}

/**
 * Check if the given calendar_event is either a user or group override
 * event for quiz.
 *
 * @param calendar_event $event The calendar event to check
 * @return bool
 */
function quiz_is_overriden_calendar_event(\calendar_event $event) {
    global $DB;

    if (!isset($event->modulename)) {
        return false;
    }

    if ($event->modulename != 'quiz') {
        return false;
    }

    if (!isset($event->instance)) {
        return false;
    }

    if (!isset($event->userid) && !isset($event->groupid)) {
        return false;
    }

    $overrideparams = [
        'quiz' => $event->instance
    ];

    if (isset($event->groupid)) {
        $overrideparams['groupid'] = $event->groupid;
    } else if (isset($event->userid)) {
        $overrideparams['userid'] = $event->userid;
    }

    return $DB->record_exists('quiz_overrides', $overrideparams);
}

/**

<  * Retrieves tag information for the given list of quiz slot ids.
<  * Currently the only slots that have tags are random question slots.
<  *
<  * Example:
<  * If we have 3 slots with id 1, 2, and 3. The first slot has two tags, the second
<  * has one tag, and the third has zero tags. The return structure will look like:
<  * [
<  *      1 => [
<  *          quiz_slot_tags.id => { ...tag data... },
<  *          quiz_slot_tags.id => { ...tag data... },
<  *      ],
<  *      2 => [
<  *          quiz_slot_tags.id => { ...tag data... },
<  *      ],
<  *      3 => [],
<  * ]
<  *
<  * @param int[] $slotids The list of id for the quiz slots.
<  * @return array[] List of quiz_slot_tags records indexed by slot id.
<  */
< function quiz_retrieve_tags_for_slot_ids($slotids) {
<     global $DB;
< 
<     if (empty($slotids)) {
<         return [];
<     }
< 
<     $slottags = $DB->get_records_list('quiz_slot_tags', 'slotid', $slotids);
<     $tagsbyid = core_tag_tag::get_bulk(array_filter(array_column($slottags, 'tagid')), 'id, name');
<     $tagsbyname = false; // It will be loaded later if required.
<     $emptytagids = array_reduce($slotids, function($carry, $slotid) {
<         $carry[$slotid] = [];
<         return $carry;
<     }, []);
< 
<     return array_reduce(
<         $slottags,
<         function($carry, $slottag) use ($slottags, $tagsbyid, $tagsbyname) {
<             if (isset($tagsbyid[$slottag->tagid])) {
<                 // Make sure that we're returning the most updated tag name.
<                 $slottag->tagname = $tagsbyid[$slottag->tagid]->name;
<             } else {
<                 if ($tagsbyname === false) {
<                     // We were hoping that this query could be avoided, but life
<                     // showed its other side to us!
<                     $tagcollid = core_tag_area::get_collection('core', 'question');
<                     $tagsbyname = core_tag_tag::get_by_name_bulk(
<                         $tagcollid,
<                         array_column($slottags, 'tagname'),
<                         'id, name'
<                     );
<                 }
<                 if (isset($tagsbyname[$slottag->tagname])) {
<                     // Make sure that we're returning the current tag id that matches
<                     // the given tag name.
<                     $slottag->tagid = $tagsbyname[$slottag->tagname]->id;
<                 } else {
<                     // The tag does not exist anymore (neither the tag id nor the tag name
<                     // matches an existing tag).
<                     // We still need to include this row in the result as some callers might
<                     // be interested in these rows. An example is the editing forms that still
<                     // need to display tag names even if they don't exist anymore.
<                     $slottag->tagid = null;
<                 }
<             }
< 
<             $carry[$slottag->slotid][$slottag->id] = $slottag;
<             return $carry;
<         },
<         $emptytagids
<     );
< }
< 
< /**
<  * Retrieves tag information for the given quiz slot.
<  * A quiz slot have some tags if and only if it is representing a random question by tags.
<  *
<  * @param int $slotid The id of the quiz slot.
<  * @return stdClass[] List of quiz_slot_tags records.
<  */
< function quiz_retrieve_slot_tags($slotid) {
<     $slottags = quiz_retrieve_tags_for_slot_ids([$slotid]);
<     return $slottags[$slotid];
< }
< 
< /**
<  * Retrieves tag ids for the given quiz slot.
<  * A quiz slot have some tags if and only if it is representing a random question by tags.
<  *
<  * @param int $slotid The id of the quiz slot.
<  * @return int[]
<  */
< function quiz_retrieve_slot_tag_ids($slotid) {
<     $tags = quiz_retrieve_slot_tags($slotid);
< 
<     // Only work with tags that exist.
<     return array_filter(array_column($tags, 'tagid'));
< }
< 
< /**


 * Get quiz attempt and handling error.
 *
 * @param int $attemptid the id of the current attempt.
 * @param int|null $cmid the course_module id for this quiz.

<  * @return quiz_attempt $attemptobj all the data about the quiz attempt.
<  * @throws moodle_exception



>  * @return quiz_attempt all the data about the quiz attempt.


 */
function quiz_create_attempt_handling_errors($attemptid, $cmid = null) {
    try {
        $attempobj = quiz_attempt::create($attemptid);
    } catch (moodle_exception $e) {
        if (!empty($cmid)) {
            list($course, $cm) = get_course_and_cm_from_cmid($cmid, 'quiz');

<             $continuelink = new moodle_url('/mod/quiz/view.php', array('id' => $cmid));



>             $continuelink = new moodle_url('/mod/quiz/view.php', ['id' => $cmid]);


            $context = context_module::instance($cm->id);
            if (has_capability('mod/quiz:preview', $context)) {
                throw new moodle_exception('attempterrorcontentchange', 'quiz', $continuelink);
            } else {
                throw new moodle_exception('attempterrorcontentchangeforuser', 'quiz', $continuelink);
            }
        } else {
            throw new moodle_exception('attempterrorinvalid', 'quiz');
        }
    }
    if (!empty($cmid) && $attempobj->get_cmid() != $cmid) {
        throw new moodle_exception('invalidcoursemodule');
    } else {
        return $attempobj;
    }
}