Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * Class for converting attempt data for calculated questions when upgrading

 * attempts to the new question engine.

 *

 * This class is used by the code in question/engine/upgrade/upgradelib.php.

 *

 * @package    qtype_calculated

 * @copyright  2011 The Open University

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

 */

class qtype_calculated_qe2_attempt_updater extends question_qtype_attempt_updater {

    protected $selecteditem = null;

    /** @var array variable name => value */

    protected $values = [];

    /** @var array variable names wrapped in {...}. Used by {@link substitute_values()}. */

    protected $search = [];

    /**

     * @var array variable values, with negative numbers wrapped in (...).

     * Used by {@link substitute_values()}.

     */

    protected $safevalue = [];

    /**

     * @var array variable values, with negative numbers wrapped in (...).

     * Used by {@link substitute_values()}.

     */

    protected $prettyvalue = [];

    public function question_summary() {

        return ''; // Done later, after we know which dataset is used.

    }

    public function right_answer() {

        foreach ($this->question->options->answers as $ans) {

            if ($ans->fraction > 0.999) {

                $right = $this->calculate($ans->answer);

                if (empty($this->question->options->units)) {

                    return $right;

                }

                $unit = reset($this->question->options->units);

                $unit = $unit->unit;

                if (!empty($this->question->options->unitsleft)) {

                    return $unit . ' ' . $right;

                } else {

                    return $right . ' ' . $unit;

                }

            }

        }

    }

    protected function parse_response($state) {

        if (strpos($state->answer, '-') < 7) {

            // Broken state, skip it.

            throw new coding_exception("Brokes state {$state->id} for calculated

                    question {$state->question}. (It did not specify a dataset.");

        }

        [$datasetbit, $realanswer] = explode('-', $state->answer, 2);

        $selecteditem = substr($datasetbit, 7);

        if (is_null($this->selecteditem)) {

            $this->load_dataset($selecteditem);

        } else if ($this->selecteditem != $selecteditem) {

            $this->logger->log_assumption("Different states for calculated question

                    {$state->question} used different dataset items. Ignoring the change

                    in state {$state->id} and coninuting to use item {$this->selecteditem}.");

        }

        if (!$realanswer) {

            return ['', ''];

        }

        if (strpos($realanswer, '|||||') === false) {

            $answer = $realanswer;

            $unit = '';

        } else {

            [$answer, $unit] = explode('|||||', $realanswer, 2);

        }

        return [$answer, $unit];

    }

    public function response_summary($state) {

        [$answer, $unit] = $this->parse_response($state);

        if (empty($answer) && empty($unit)) {

            $resp = null;

        } else {

            $resp = $answer;

        }

        if (!empty($unit)) {

            if (!empty($this->question->options->unitsleft)) {

                $resp = trim($unit . ' ' . $resp);

            } else {

                $resp = trim($resp . ' ' . $unit);

            }

        }

        return $resp;

    }

    public function was_answered($state) {

        return !empty($state->answer);

    }

    public function set_first_step_data_elements($state, &$data) {

        $this->parse_response($state);

        $this->updater->qa->questionsummary = $this->to_text(

                $this->replace_expressions_in_text($this->question->questiontext));

        $this->updater->qa->rightanswer = $this->right_answer($this->question);

        foreach ($this->values as $name => $value) {

            $data['_var_' . $name] = $value;

        }

        $data['_separators'] = '.$,';

    }

    public function supply_missing_first_step_data(&$data) {

        $data['_separators'] = '.$,';

    }

    public function set_data_elements_for_step($state, &$data) {

        if (empty($state->answer)) {

            return;

        }

        [$answer, $unit] = $this->parse_response($state);

        if (

            !empty($this->question->options->showunits) &&

                $this->question->options->showunits == 1

        ) {

            // Multichoice units.

            $data['answer'] = $answer;

            $data['unit'] = $unit;

        } else if (!empty($this->question->options->unitsleft)) {

            if (!empty($unit)) {

                $data['answer'] = $unit . ' ' . $answer;

            } else {

                $data['answer'] = $answer;

            }

        } else {

            if (!empty($unit)) {

                $data['answer'] = $answer . ' ' . $unit;

            } else {

                $data['answer'] = $answer;

            }

        }

    }

    public function load_dataset($selecteditem) {

        $this->selecteditem = $selecteditem;

        $this->updater->qa->variant = $selecteditem;

        $this->values = $this->qeupdater->load_dataset(

                $this->question->id, $selecteditem);

        // Prepare an array for {@link substitute_values()}.

        $this->search = [];

        $this->safevalue = [];

        $this->prettyvalue = [];

        foreach ($this->values as $name => $value) {

            if (!is_numeric($value)) {

                $a = new stdClass();

                $a->name = '{' . $name . '}';

                $a->value = $value;

                throw new moodle_exception('notvalidnumber', 'qtype_calculated', '', $a);

            }

            $this->search[] = '{' . $name . '}';

            $this->safevalue[] = '(' . $value . ')';

            $this->prettyvalue[] = $this->format_float($value);

        }

    }

    /**

     * This function should be identical to

     * {@link qtype_calculated_variable_substituter::format_float()}. Except that

     * we do not try to do locale-aware replacement of the decimal point.

     *

     * Having to copy it here is a pain, but it is the standard rule about not

     * using library code (which may change in future) in upgrade code, which

     * exists at a point in time.

     *

     * Display a float properly formatted with a certain number of decimal places.

     * @param number $x the number to format

     * @param int $length restrict to this many decimal places or significant

     *      figures. If null, the number is not rounded.

     * @param int format 1 => decimalformat, 2 => significantfigures.

     * @return string formtted number.

     */

    public function format_float($x, $length = null, $format = null) {

        if (!is_null($length) && !is_null($format)) {

            if ($format == 1) {

                // Decimal places.

                $x = sprintf('%.' . $length . 'F', $x);

            } else if ($format == 2) {

                // Significant figures.

                $x = sprintf('%.' . $length . 'g', $x);

            }

        }

        return $x;

    }

    /**

     * Evaluate an expression using the variable values.

     * @param string $expression the expression. A PHP expression with placeholders

     *      like {a} for where the variables need to go.

     * @return float the computed result.

     */

    public function calculate($expression) {

        return $this->calculate_raw($this->substitute_values_for_eval($expression));

    }

    /**

     * Evaluate an expression after the variable values have been substituted.

     * @param string $expression the expression. A PHP expression with placeholders

     *      like {a} for where the variables need to go.

     * @return float the computed result.

     */

    protected function calculate_raw($expression) {

        try {

            // In older PHP versions this this is a way to validate code passed to eval.

            // The trick came from http://php.net/manual/en/function.eval.php.

            if (@eval('return true; $result = ' . $expression . ';')) {

                return eval('return ' . $expression . ';');

            }

        } catch (Throwable $e) {

            // PHP7 and later now throws ParseException and friends from eval(),

            // which is much better.

        }

        // In either case of an invalid $expression, we end here.

        return '[Invalid expression ' . $expression . ']';

    }

    /**

     * Substitute variable placehodlers like {a} with their value wrapped in ().

     * @param string $expression the expression. A PHP expression with placeholders

     *      like {a} for where the variables need to go.

     * @return string the expression with each placeholder replaced by the

     *      corresponding value.

     */

    protected function substitute_values_for_eval($expression) {

        return str_replace($this->search, $this->safevalue, $expression ?? '');

    }

    /**

     * Substitute variable placehodlers like {a} with their value without wrapping

     * the value in anything.

     * @param string $text some content with placeholders

     *      like {a} for where the variables need to go.

     * @return string the expression with each placeholder replaced by the

     *      corresponding value.

     */

    protected function substitute_values_pretty($text) {

        return str_replace($this->search, $this->prettyvalue, $text ?? '');

    }

    /**

     * Replace any embedded variables (like {a}) or formulae (like {={a} + {b}})

     * in some text with the corresponding values.

     * @param string $text the text to process.

     * @return string the text with values substituted.

     */

    public function replace_expressions_in_text($text, $length = null, $format = null) {

        if ($text === null || $text === '') {

            return $text;

        }

        $vs = $this; // Can't see to use $this in a PHP closure.

        $text = preg_replace_callback(

            '~\{=([^{}]*(?:\{[^{}]+}[^{}]*)*)}~',

            function ($matches) use ($vs, $format, $length) {

                return $vs->format_float($vs->calculate($matches[1]), $length, $format);

            },

            $text

        );

        return $this->substitute_values_pretty($text);

    }

}