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

namespace core\output;

use breadcrumb_navigation_node;

use cm_info;

use core\hook\output\after_http_headers;

use core_block\output\block_contents;

use core_block\output\block_move_target;

use core_completion\cm_completion_details;

use core\context;

use core_tag\output\taglist;

use core_text;

use core_useragent;

use core\check\check as check_check;

use core\check\result as check_result;

use core\context\system as context_system;

use core\context\course as context_course;

use core\di;

use core\exception\coding_exception;

use core\hook\manager as hook_manager;

use core\hook\output\after_standard_main_region_html_generation;

use core\hook\output\before_footer_html_generation;

use core\hook\output\before_html_attributes;

use core\hook\output\before_http_headers;

use core\hook\output\before_standard_footer_html_generation;

use core\hook\output\before_standard_top_of_body_html_generation;

use core\output\actions\component_action;

use core\output\actions\popup_action;

use core\output\local\properties\badge;

use core\plugin_manager;

use moodleform;

use moodle_page;

use moodle_url;

use navigation_node;

use rating;

use rating_manager;

use stdClass;

use HTML_QuickForm_element;

/**

 * The standard implementation of the core_renderer interface.

 *

 * @copyright 2009 Tim Hunt

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

 * @since Moodle 2.0

 * @package core

 * @category output

 */

class core_renderer extends renderer_base {

    /**

     * Do NOT use, please use <?php echo $OUTPUT->main_content() ?>

     * in layout files instead.

     * @deprecated

     * @var string used in {@see core_renderer::header()}.

     */

    const MAIN_CONTENT_TOKEN = '[MAIN CONTENT GOES HERE]';

    /**

     * @var string Used to pass information from {@see core_renderer::doctype()} to

     * @see core_renderer::standard_head_html()

     */

    protected $contenttype;

    /**

     * @var string Used by {@see core_renderer::redirect_message()} method to communicate

     * with {@see core_renderer::header()}.

     */

    protected $metarefreshtag = '';

    /**

     * @var string Unique token for the closing HTML

     */

    protected $unique_end_html_token; // phpcs:ignore moodle.NamingConventions.ValidVariableName.MemberNameUnderscore

    /**

     * @var string Unique token for performance information

     */

    protected $unique_performance_info_token; // phpcs:ignore moodle.NamingConventions.ValidVariableName.MemberNameUnderscore

    /**

     * @var string Unique token for the main content.

     */

    protected $unique_main_content_token; // phpcs:ignore moodle.NamingConventions.ValidVariableName.MemberNameUnderscore

    /** @var custom_menu_item language The language menu if created */

    protected $language = null;

    /** @var string The current selector for an element being streamed into */

    protected $currentselector = '';

    /** @var string The current element tag which is being streamed into */

    protected $currentelement = '';

    /**

     * Constructor

     *

     * @param moodle_page $page the page we are doing output for.

     * @param string $target one of rendering target constants

     */

    public function __construct(moodle_page $page, $target) {

        $this->opencontainers = $page->opencontainers;

        $this->page = $page;

        $this->target = $target;

        $this->unique_end_html_token = '%%ENDHTML-' . sesskey() . '%%';

        $this->unique_performance_info_token = '%%PERFORMANCEINFO-' . sesskey() . '%%';

        $this->unique_main_content_token = '[MAIN CONTENT GOES HERE - ' . sesskey() . ']';

    }

    /**

     * Get the DOCTYPE declaration that should be used with this page. Designed to

     * be called in theme layout.php files.

     *

     * @return string the DOCTYPE declaration that should be used.

     */

    public function doctype() {

        if ($this->page->theme->doctype === 'html5') {

            $this->contenttype = 'text/html; charset=utf-8';

            return "<!DOCTYPE html>\n";

        } else if ($this->page->theme->doctype === 'xhtml5') {

            $this->contenttype = 'application/xhtml+xml; charset=utf-8';

            return "<!DOCTYPE html>\n";

        } else {

            // legacy xhtml 1.0

            $this->contenttype = 'text/html; charset=utf-8';

            return ('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' . "\n");

        }

    }

    /**

     * The attributes that should be added to the <html> tag. Designed to

     * be called in theme layout.php files.

     *

     * @return string HTML fragment.

     */

    public function htmlattributes() {

        $return = get_html_lang(true);

        $hook = new before_html_attributes($this);

        if ($this->page->theme->doctype !== 'html5') {

            $hook->add_attribute('xmlns', 'http://www.w3.org/1999/xhtml');

        }

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        foreach ($hook->get_attributes() as $key => $val) {

            $val = s($val);

            $return .= " $key=\"$val\"";

        }

        return $return;

    }

    /**

     * The standard tags (meta tags, links to stylesheets and JavaScript, etc.)

     * that should be included in the <head> tag. Designed to be called in theme

     * layout.php files.

     *

     * @return string HTML fragment.

     */

    public function standard_head_html() {

        global $CFG, $SESSION, $SITE;

        // Before we output any content, we need to ensure that certain

        // page components are set up.

        // Blocks must be set up early as they may require javascript which

        // has to be included in the page header before output is created.

        foreach ($this->page->blocks->get_regions() as $region) {

            $this->page->blocks->ensure_content_created($region, $this);

        }

        // Give plugins an opportunity to add any head elements. The callback

        // must always return a string containing valid html head content.

        $hook = new \core\hook\output\before_standard_head_html_generation($this);

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        // Allow a url_rewrite plugin to setup any dynamic head content.

        if (isset($CFG->urlrewriteclass) && !isset($CFG->upgraderunning)) {

            $class = $CFG->urlrewriteclass;

            $hook->add_html($class::html_head_setup());

        }

        $hook->add_html('<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />' . "\n");

        $hook->add_html('<meta name="keywords" content="moodle, ' . $this->page->title . '" />' . "\n");

        // This is only set by the {@see redirect()} method

        $hook->add_html($this->metarefreshtag);

        // Check if a periodic refresh delay has been set and make sure we arn't

        // already meta refreshing

        if ($this->metarefreshtag == '' && $this->page->periodicrefreshdelay !== null) {

            $hook->add_html(

                html_writer::empty_tag('meta', [

                    'http-equiv' => 'refresh',

                    'content' => $this->page->periodicrefreshdelay . ';url=' . $this->page->url->out(),

                ]),

            );

        }

        $output = $hook->get_output();

        // Set up help link popups for all links with the helptooltip class

        $this->page->requires->js_init_call('M.util.help_popups.setup');

        $focus = $this->page->focuscontrol;

        if (!empty($focus)) {

            if (preg_match("#forms\['([a-zA-Z0-9]+)'\].elements\['([a-zA-Z0-9]+)'\]#", $focus, $matches)) {

                // This is a horrifically bad way to handle focus but it is passed in

                // through messy formslib::moodleform

                $this->page->requires->js_function_call('old_onload_focus', [$matches[1], $matches[2]]);

            } else if (strpos($focus, '.') !== false) {

                // Old style of focus, bad way to do it

                debugging('This code is using the old style focus event, Please update this code to focus on an element id or the moodleform focus method.', DEBUG_DEVELOPER);

                $this->page->requires->js_function_call('old_onload_focus', explode('.', $focus, 2));

            } else {

                // Focus element with given id

                $this->page->requires->js_function_call('focuscontrol', [$focus]);

            }

        }

        // Get the theme stylesheet - this has to be always first CSS, this loads also styles.css from all plugins;

        // any other custom CSS can not be overridden via themes and is highly discouraged

        $urls = $this->page->theme->css_urls($this->page);

        foreach ($urls as $url) {

            $this->page->requires->css_theme($url);

        }

        // Get the theme javascript head and footer

        if ($jsurl = $this->page->theme->javascript_url(true)) {

            $this->page->requires->js($jsurl, true);

        }

        if ($jsurl = $this->page->theme->javascript_url(false)) {

            $this->page->requires->js($jsurl);

        }

        // Get any HTML from the page_requirements_manager.

        $output .= $this->page->requires->get_head_code($this->page, $this);

        // List alternate versions.

        foreach ($this->page->alternateversions as $type => $alt) {

            $output .= html_writer::empty_tag('link', [

                'rel' => 'alternate',

                'type' => $type,

                'title' => $alt->title,

                'href' => $alt->url,

            ]);

        }

        // Add noindex tag if relevant page and setting applied.

        $allowindexing = isset($CFG->allowindexing) ? $CFG->allowindexing : 0;

        $loginpages = ['login-index', 'login-signup'];

        if ($allowindexing == 2 || ($allowindexing == 0 && in_array($this->page->pagetype, $loginpages))) {

            if (!isset($CFG->additionalhtmlhead)) {

                $CFG->additionalhtmlhead = '';

            }

            if (stripos($CFG->additionalhtmlhead, '<meta name="robots" content="noindex" />') === false) {

                $CFG->additionalhtmlhead .= '<meta name="robots" content="noindex" />';

            }

        }

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

            $output .= "\n" . $CFG->additionalhtmlhead;

        }

        if ($this->page->pagelayout == 'frontpage') {

            $summary = s(strip_tags(format_text($SITE->summary, FORMAT_HTML)));

            if (!empty($summary)) {

                $output .= "<meta name=\"description\" content=\"$summary\" />\n";

            }

        }

        return $output;

    }

    /**

     * The standard tags (typically skip links) that should be output just inside

     * the start of the <body> tag. Designed to be called in theme layout.php files.

     *

     * @return string HTML fragment.

     */

    public function standard_top_of_body_html() {

        global $CFG;

        $output = $this->page->requires->get_top_of_body_code($this);

        if ($this->page->pagelayout !== 'embedded' && !empty($CFG->additionalhtmltopofbody)) {

            $output .= "\n" . $CFG->additionalhtmltopofbody;

        }

        // Allow components to add content to the top of the body.

        $hook = new before_standard_top_of_body_html_generation($this, $output);

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        $output = $hook->get_output();

        $output .= $this->maintenance_warning();

        return $output;

    }

    /**

     * Scheduled maintenance warning message.

     *

     * Note: This is a nasty hack to display maintenance notice, this should be moved

     *       to some general notification area once we have it.

     *

     * @return string

     */

    public function maintenance_warning() {

        global $CFG;

        $output = '';

        if (isset($CFG->maintenance_later) and $CFG->maintenance_later > time()) {

            $timeleft = $CFG->maintenance_later - time();

            // If timeleft less than 30 sec, set the class on block to error to highlight.

            $errorclass = ($timeleft < 30) ? 'alert-error alert-danger' : 'alert-warning';

            $output .= $this->box_start($errorclass . ' moodle-has-zindex maintenancewarning alert');

            $a = new stdClass();

            $a->hour = (int)($timeleft / 3600);

            $a->min = (int)(floor($timeleft / 60) % 60);

            $a->sec = (int)($timeleft % 60);

            if ($a->hour > 0) {

                $output .= get_string('maintenancemodeisscheduledlong', 'admin', $a);

            } else {

                $output .= get_string('maintenancemodeisscheduled', 'admin', $a);

            }

            $output .= $this->box_end();

            $this->page->requires->yui_module(

                'moodle-core-maintenancemodetimer',

                'M.core.maintenancemodetimer',

                [['timeleftinsec' => $timeleft]]

            );

            $this->page->requires->strings_for_js(

                ['maintenancemodeisscheduled', 'maintenancemodeisscheduledlong', 'sitemaintenance'],

                'admin'

            );

        }

        return $output;

    }

    /**

     * content that should be output in the footer area

     * of the page. Designed to be called in theme layout.php files.

     *

     * @return string HTML fragment.

     */

    public function standard_footer_html() {

        if (during_initial_install()) {

            // Debugging info can not work before install is finished,

            // in any case we do not want any links during installation!

            return '';

        }

        $hook = new before_standard_footer_html_generation($this);

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        $output = $hook->get_output();

        if ($this->page->devicetypeinuse == 'legacy') {

            // The legacy theme is in use print the notification

            $output .= html_writer::tag('div', get_string('legacythemeinuse'), ['class' => 'legacythemeinuse']);

        }

        // Get links to switch device types (only shown for users not on a default device)

        $output .= $this->theme_switch_links();

        return $output;

    }

    /**

     * Performance information and validation links for debugging.

     *

     * @return string HTML fragment.

     */

    public function debug_footer_html() {

        global $CFG, $SCRIPT;

        $output = '';

        if (during_initial_install()) {

            // Debugging info can not work before install is finished.

            return $output;

        }

        // This function is normally called from a layout.php file

        // but some of the content won't be known until later, so we return a placeholder

        // for now. This will be replaced with the real content in the footer.

        $output .= $this->unique_performance_info_token;

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

            $output .= '<div class="performanceinfo pageinfo">' . get_string(

                'pageinfodebugsummary',

                'core_admin',

                $this->page->debug_summary()

            ) . '</div>';

        }

        if (debugging(null, DEBUG_DEVELOPER) and has_capability('moodle/site:config', context_system::instance())) {  // Only in developer mode

            // Add link to profiling report if necessary

            if (function_exists('profiling_is_running') && profiling_is_running()) {

                $txt = get_string('profiledscript', 'admin');

                $title = get_string('profiledscriptview', 'admin');

                $url = $CFG->wwwroot . '/admin/tool/profiling/index.php?script=' . urlencode($SCRIPT);

                $link = '<a title="' . $title . '" href="' . $url . '">' . $txt . '</a>';

                $output .= '<div class="profilingfooter">' . $link . '</div>';

            }

            $purgeurl = new moodle_url('/admin/purgecaches.php', [

                'confirm' => 1,

                'sesskey' => sesskey(),

                'returnurl' => $this->page->url->out_as_local_url(false),

            ]);

            $output .= '<div class="purgecaches">' .

                    html_writer::link($purgeurl, get_string('purgecaches', 'admin')) . '</div>';

            // Reactive module debug panel.

            $output .= $this->render_from_template('core/local/reactive/debugpanel', []);

        }

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

            $siteurl = qualified_me();

            $nuurl = new moodle_url('https://validator.w3.org/nu/', ['doc' => $siteurl, 'showsource' => 'yes']);

            $waveurl = new moodle_url('https://wave.webaim.org/report#/' . urlencode($siteurl));

            $validatorlinks = [

                html_writer::link($nuurl, get_string('validatehtml')),

                html_writer::link($waveurl, get_string('wcagcheck')),

            ];

            $validatorlinkslist = html_writer::alist($validatorlinks, ['class' => 'list-unstyled ms-1']);

            $output .= html_writer::div($validatorlinkslist, 'validators');

        }

        return $output;

    }

    /**

     * Returns standard main content placeholder.

     * Designed to be called in theme layout.php files.

     *

     * @return string HTML fragment.

     */

    public function main_content() {

        // This is here because it is the only place we can inject the "main" role over the entire main content area

        // without requiring all theme's to manually do it, and without creating yet another thing people need to

        // remember in the theme.

        // This is an unfortunate hack. DO NO EVER add anything more here.

        // DO NOT add classes.

        // DO NOT add an id.

        return '<div role="main">' . $this->unique_main_content_token . '</div>';

    }

    /**

     * @deprecated since Moodle 4.3 MDL-78744

     */

    #[\core\attribute\deprecated(null, since: '4.3', mdl: 'MDL-78744', final: true)]

    public function activity_information() {

        \core\deprecation::emit_deprecation([self::class, __FUNCTION__]);

    }

    /**

     * Returns standard navigation between activities in a course.

     *

     * @return string the navigation HTML.

     */

    public function activity_navigation() {

        // First we should check if we want to add navigation.

        $context = $this->page->context;

        if (

            ($this->page->pagelayout !== 'incourse' && $this->page->pagelayout !== 'frametop')

            || $context->contextlevel != CONTEXT_MODULE

        ) {

            return '';

        }

        // If the activity is in stealth mode, show no links.

        if ($this->page->cm->is_stealth()) {

            return '';

        }

        $course = $this->page->cm->get_course();

        $courseformat = course_get_format($course);

        // If the theme implements course index and the current course format uses course index and the current

        // page layout is not 'frametop' (this layout does not support course index), show no links.

        if (

            $this->page->theme->usescourseindex && $courseformat->uses_course_index() &&

                $this->page->pagelayout !== 'frametop'

        ) {

            return '';

        }

        // Get a list of all the activities in the course.

        $modules = get_fast_modinfo($course->id)->get_cms();

        // Put the modules into an array in order by the position they are shown in the course.

        $mods = [];

        $activitylist = [];

        foreach ($modules as $module) {

            // Only add activities the user can access, aren't in stealth mode, are of a type that is visible on the course,

            // and have a url (eg. mod_label does not).

            if (!$module->uservisible || $module->is_stealth() || empty($module->url) || !$module->is_of_type_that_can_display()) {

                continue;

            }

            $mods[$module->id] = $module;

            // No need to add the current module to the list for the activity dropdown menu.

            if ($module->id == $this->page->cm->id) {

                continue;

            }

            // Module name.

            $modname = $module->get_formatted_name();

            // Display the hidden text if necessary.

            if (!$module->visible) {

                $modname .= ' ' . get_string('hiddenwithbrackets');

            }

            // Module URL.

            $linkurl = new moodle_url($module->url, ['forceview' => 1]);

            // Add module URL (as key) and name (as value) to the activity list array.

            $activitylist[$linkurl->out(false)] = $modname;

        }

        $nummods = count($mods);

        // If there are only one or fewer mods then do nothing.

        if ($nummods <= 1) {

            return '';

        }

        // Get an array of just the course module ids used to get the cmid value based on their position in the course.

        $modids = array_keys($mods);

        // Get the position in the array of the course module we are viewing.

        $position = array_search($this->page->cm->id, $modids);

        $prevmod = null;

        $nextmod = null;

        // Check if we have a previous mod to show.

        if ($position > 0) {

            $prevmod = $mods[$modids[$position - 1]];

        }

        // Check if we have a next mod to show.

        if ($position < ($nummods - 1)) {

            $nextmod = $mods[$modids[$position + 1]];

        }

        $activitynav = new \core_course\output\activity_navigation($prevmod, $nextmod, $activitylist);

        $renderer = $this->page->get_renderer('core', 'course');

        return $renderer->render($activitynav);

    }

    /**

     * The standard tags (typically script tags that are not needed earlier) that

     * should be output after everything else. Designed to be called in theme layout.php files.

     *

     * @return string HTML fragment.

     */

    public function standard_end_of_body_html() {

        global $CFG;

        // This function is normally called from a layout.php file in {@see core_renderer::header()}

        // but some of the content won't be known until later, so we return a placeholder

        // for now. This will be replaced with the real content in {@see core_renderer::footer()}.

        $output = '';

        if ($this->page->pagelayout !== 'embedded' && !empty($CFG->additionalhtmlfooter)) {

            $output .= "\n" . $CFG->additionalhtmlfooter;

        }

        $output .= $this->unique_end_html_token;

        return $output;

    }

    /**

     * The standard HTML that should be output just before the <footer> tag.

     * Designed to be called in theme layout.php files.

     *

     * @return string HTML fragment.

     */

    public function standard_after_main_region_html() {

        global $CFG;

        $hook = new after_standard_main_region_html_generation($this);

        if ($this->page->pagelayout !== 'embedded' && !empty($CFG->additionalhtmlbottomofbody)) {

            $hook->add_html("\n");

            $hook->add_html($CFG->additionalhtmlbottomofbody);

        }

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        return $hook->get_output();

    }

    /**

     * Return the standard string that says whether you are logged in (and switched

     * roles/logged in as another user).

     * @param bool $withlinks if false, then don't include any links in the HTML produced.

     * If not set, the default is the nologinlinks option from the theme config.php file,

     * and if that is not set, then links are included.

     * @return string HTML fragment.

     */

    public function login_info($withlinks = null) {

        global $USER, $CFG, $DB, $SESSION;

        if (during_initial_install()) {

            return '';

        }

        if (is_null($withlinks)) {

            $withlinks = empty($this->page->layout_options['nologinlinks']);

        }

        $course = $this->page->course;

        if (\core\session\manager::is_loggedinas()) {

            $realuser = \core\session\manager::get_realuser();

            $fullname = fullname($realuser);

            if ($withlinks) {

                $loginastitle = get_string('loginas');

                $realuserinfo = " [<a href=\"$CFG->wwwroot/course/loginas.php?id=$course->id&amp;sesskey=" . sesskey() . "\"";

                $realuserinfo .= "title =\"" . $loginastitle . "\">$fullname</a>] ";

            } else {

                $realuserinfo = " [$fullname] ";

            }

        } else {

            $realuserinfo = '';

        }

        $loginpage = $this->is_login_page();

        $loginurl = get_login_url();

        if (empty($course->id)) {

            // $course->id is not defined during installation

            return '';

        } else if (isloggedin()) {

            $context = context_course::instance($course->id);

            $fullname = fullname($USER);

            // Since Moodle 2.0 this link always goes to the public profile page (not the course profile page)

            if ($withlinks) {

                $linktitle = get_string('viewprofile');

                $username = "<a href=\"$CFG->wwwroot/user/profile.php?id=$USER->id\" title=\"$linktitle\">$fullname</a>";

            } else {

                $username = $fullname;

            }

            if (is_mnet_remote_user($USER) and $idprovider = $DB->get_record('mnet_host', ['id' => $USER->mnethostid])) {

                if ($withlinks) {

                    $username .= " from <a href=\"{$idprovider->wwwroot}\">{$idprovider->name}</a>";

                } else {

                    $username .= " from {$idprovider->name}";

                }

            }

            if (isguestuser()) {

                $loggedinas = $realuserinfo . get_string('loggedinasguest');

                if (!$loginpage && $withlinks) {

                    $loggedinas .= " (<a href=\"$loginurl\">" . get_string('login') . '</a>)';

                }

            } else if (is_role_switched($course->id)) { // Has switched roles

                $rolename = '';

                if ($role = $DB->get_record('role', ['id' => $USER->access['rsw'][$context->path]])) {

                    $rolename = ': ' . role_get_name($role, $context);

                }

                $loggedinas = get_string('loggedinas', 'moodle', $username) . $rolename;

                if ($withlinks) {

                    $url = new moodle_url('/course/switchrole.php', ['id' => $course->id, 'sesskey' => sesskey(), 'switchrole' => 0, 'returnurl' => $this->page->url->out_as_local_url(false)]);

                    $loggedinas .= ' (' . html_writer::tag('a', get_string('switchrolereturn'), ['href' => $url]) . ')';

                }

            } else {

                $loggedinas = $realuserinfo . get_string('loggedinas', 'moodle', $username);

                if ($withlinks) {

                    $loggedinas .= " (<a href=\"$CFG->wwwroot/login/logout.php?sesskey=" . sesskey() . "\">" . get_string('logout') . '</a>)';

                }

            }

        } else {

            $loggedinas = get_string('loggedinnot', 'moodle');

            if (!$loginpage && $withlinks) {

                $loggedinas .= " (<a href=\"$loginurl\">" . get_string('login') . '</a>)';

            }

        }

        $loggedinas = '<div class="logininfo">' . $loggedinas . '</div>';

        if (isset($SESSION->justloggedin)) {

            unset($SESSION->justloggedin);

            if (!isguestuser()) {

                // Include this file only when required.

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

                if (($count = user_count_login_failures($USER)) && !empty($CFG->displayloginfailures)) {

                    $loggedinas .= '<div class="loginfailures">';

                    $a = new stdClass();

                    $a->attempts = $count;

                    $loggedinas .= get_string('failedloginattempts', '', $a);

                    if (file_exists("$CFG->dirroot/report/log/index.php") and has_capability('report/log:view', context_system::instance())) {

                        $loggedinas .= ' (' . html_writer::link(new moodle_url('/report/log/index.php', [

                            'chooselog' => 1,

                            'id' => 0,

                            'modid' => 'site_errors',

                        ]), get_string('logs')) . ')';

                    }

                    $loggedinas .= '</div>';

                }

            }

        }

        return $loggedinas;

    }

    /**

     * Check whether the current page is a login page.

     *

     * @since Moodle 2.9

     * @return bool

     */

    protected function is_login_page() {

        // This is a real bit of a hack, but its a rarety that we need to do something like this.

        // In fact the login pages should be only these two pages and as exposing this as an option for all pages

        // could lead to abuse (or at least unneedingly complex code) the hack is the way to go.

        return in_array(

            $this->page->url->out_as_local_url(false, []),

            [

                '/login/index.php',

                '/login/forgot_password.php',

            ]

        );

    }

    /**

     * Return the 'back' link that normally appears in the footer.

     *

     * @return string HTML fragment.

     */

    public function home_link() {

        global $CFG, $SITE;

        if ($this->page->pagetype == 'site-index') {

            // Special case for site home page - please do not remove

            return '<div class="sitelink">' .

                   '<a title="Moodle" class="d-inline-block aalink" href="http://moodle.org/">' .

                   '<img src="' . $this->image_url('moodlelogo_grayhat') . '" alt="' . get_string('moodlelogo') . '" /></a></div>';

        } else if (!empty($CFG->target_release) && $CFG->target_release != $CFG->release) {

            // Special case for during install/upgrade.

            return '<div class="sitelink">' .

                   '<a title="Moodle" href="http://docs.moodle.org/en/Administrator_documentation" onclick="this.target=\'_blank\'">' .

                   '<img src="' . $this->image_url('moodlelogo_grayhat') . '" alt="' . get_string('moodlelogo') . '" /></a></div>';

        } else if ($this->page->course->id == $SITE->id || strpos($this->page->pagetype, 'course-view') === 0) {

            return '<div class="homelink"><a href="' . $CFG->wwwroot . '/">' .

                    get_string('home') . '</a></div>';

        } else {

            return '<div class="homelink"><a href="' . $CFG->wwwroot . '/course/view.php?id=' . $this->page->course->id . '">' .

                    format_string($this->page->course->shortname, true, ['context' => $this->page->context]) . '</a></div>';

        }

    }

    /**

     * Redirects the user by any means possible given the current state

     *

     * This function should not be called directly, it should always be called using

     * the redirect function in lib/weblib.php

     *

     * The redirect function should really only be called before page output has started

     * however it will allow itself to be called during the state STATE_IN_BODY

     *

     * @param string $encodedurl The URL to send to encoded if required

     * @param string $message The message to display to the user if any

     * @param int $delay The delay before redirecting a user, if $message has been

     *         set this is a requirement and defaults to 3, set to 0 no delay

     * @param boolean $debugdisableredirect this redirect has been disabled for

     *         debugging purposes. Display a message that explains, and don't

     *         trigger the redirect.

     * @param string $messagetype The type of notification to show the message in.

     *         See constants on \core\output\notification.

     * @return string The HTML to display to the user before dying, may contain

     *         meta refresh, javascript refresh, and may have set header redirects

     */

    public function redirect_message(

        $encodedurl,

        $message,

        $delay,

        $debugdisableredirect,

        $messagetype = notification::NOTIFY_INFO,

    ) {

        global $CFG;

        $url = str_replace('&', '&', $encodedurl);

        switch ($this->page->state) {

            case moodle_page::STATE_BEFORE_HEADER:

                // No output yet it is safe to delivery the full arsenal of redirect methods

                if (!$debugdisableredirect) {

                    // Don't use exactly the same time here, it can cause problems when both redirects fire at the same time.

                    $this->metarefreshtag = '<meta http-equiv="refresh" content="' . $delay . '; url=' . $encodedurl . '" />' . "\n";

                    $this->page->requires->js_function_call('document.location.replace', [$url], false, ($delay + 3));

                }

                $output = $this->header();

                break;

            case moodle_page::STATE_PRINTING_HEADER:

                // We should hopefully never get here

                throw new coding_exception('You cannot redirect while printing the page header');

                break;

            case moodle_page::STATE_IN_BODY:

                // We really shouldn't be here but we can deal with this

                debugging("You should really redirect before you start page output");

                if (!$debugdisableredirect) {

                    $this->page->requires->js_function_call('document.location.replace', [$url], false, $delay);

                }

                $output = $this->opencontainers->pop_all_but_last();

                break;

            case moodle_page::STATE_DONE:

                // Too late to be calling redirect now

                throw new coding_exception('You cannot redirect after the entire page has been generated');

                break;

        }

        $output .= $this->notification($message, $messagetype);

        $output .= '<div class="continuebutton">(<a href="' . $encodedurl . '">' . get_string('continue') . '</a>)</div>';

        if ($debugdisableredirect) {

            $output .= '<p><strong>' . get_string('erroroutput', 'error') . '</strong></p>';

        }

        $output .= $this->footer();

        return $output;

    }

    /**

     * Start output by sending the HTTP headers, and printing the HTML <head>

     * and the start of the <body>.

     *

     * To control what is printed, you should set properties on $PAGE.

     *

     * @return string HTML that you must output this, preferably immediately.

     */

    public function header() {

        global $USER, $CFG, $SESSION;

        $hook = new before_http_headers($this);

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        if (\core\session\manager::is_loggedinas()) {

            $this->page->add_body_class('userloggedinas');

        }

        if (isset($SESSION->justloggedin) && !empty($CFG->displayloginfailures)) {

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

            // Set second parameter to false as we do not want reset the counter, the same message appears on footer.

            if ($count = user_count_login_failures($USER, false)) {

                $this->page->add_body_class('loginfailures');

            }

        }

        // If the user is logged in, and we're not in initial install,

        // check to see if the user is role-switched and add the appropriate

        // CSS class to the body element.

        if (!during_initial_install() && isloggedin() && is_role_switched($this->page->course->id)) {

            $this->page->add_body_class('userswitchedrole');

        }

        // Give themes a chance to init/alter the page object.

        $this->page->theme->init_page($this->page);

        $this->page->set_state(moodle_page::STATE_PRINTING_HEADER);

        // Find the appropriate page layout file, based on $this->page->pagelayout.

        $layoutfile = $this->page->theme->layout_file($this->page->pagelayout);

        // Render the layout using the layout file.

        $rendered = $this->render_page_layout($layoutfile);

        // Slice the rendered output into header and footer.

        $cutpos = strpos($rendered, $this->unique_main_content_token);

        if ($cutpos === false) {

            $cutpos = strpos($rendered, self::MAIN_CONTENT_TOKEN);

            $token = self::MAIN_CONTENT_TOKEN;

        } else {

            $token = $this->unique_main_content_token;

        }

        if ($cutpos === false) {

            throw new coding_exception('page layout file ' . $layoutfile . ' does not contain the main content placeholder, please include "<?php echo $OUTPUT->main_content() ?>" in theme layout file.');

        }

        $header = substr($rendered, 0, $cutpos);

        $footer = substr($rendered, $cutpos + strlen($token));

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

            debugging('The page layout file did not call $OUTPUT->doctype()');

            $header = $this->doctype() . $header;

        }

        // If this theme version is below 2.4 release and this is a course view page

        if (

            (!isset($this->page->theme->settings->version) || $this->page->theme->settings->version < 2012101500) &&

                $this->page->pagelayout === 'course' && $this->page->url->compare(new moodle_url('/course/view.php'), URL_MATCH_BASE)

        ) {

            // check if course content header/footer have not been output during render of theme layout

            $coursecontentheader = $this->course_content_header(true);

            $coursecontentfooter = $this->course_content_footer(true);

            if (!empty($coursecontentheader)) {

                // display debug message and add header and footer right above and below main content

                // Please note that course header and footer (to be displayed above and below the whole page)

                // are not displayed in this case at all.

                // Besides the content header and footer are not displayed on any other course page

                debugging('The current theme is not optimised for 2.4, the course-specific header and footer defined in course format will not be output', DEBUG_DEVELOPER);

                $header .= $coursecontentheader;

                $footer = $coursecontentfooter . $footer;

            }

        }

        send_headers($this->contenttype, $this->page->cacheable);

        $this->opencontainers->push('header/footer', $footer);

        $this->page->set_state(moodle_page::STATE_IN_BODY);

        // If an activity record has been set, activity_header will handle this.

        if (!$this->page->cm || !empty($this->page->layout_options['noactivityheader'])) {

            $header .= $this->skip_link_target('maincontent');

        }

        $hook = new after_http_headers(

            renderer: $this,

            output: $header,

        );

        di::get(hook_manager::class)->dispatch($hook);

        return $hook->get_output();

    }

    /**

     * Renders and outputs the page layout file.

     *

     * This is done by preparing the normal globals available to a script, and

     * then including the layout file provided by the current theme for the

     * requested layout.

     *

     * @param string $layoutfile The name of the layout file

     * @return string HTML code

     */

    protected function render_page_layout($layoutfile) {

        global $CFG, $SITE, $USER;

        // The next lines are a bit tricky. The point is, here we are in a method

        // of a renderer class, and this object may, or may not, be the same as

        // the global $OUTPUT object. When rendering the page layout file, we want to use

        // this object. However, people writing Moodle code expect the current

        // renderer to be called $OUTPUT, not $this, so define a variable called

        // $OUTPUT pointing at $this. The same comment applies to $PAGE and $COURSE.

        $OUTPUT = $this;

        $PAGE = $this->page;

        $COURSE = $this->page->course;

        ob_start();

        include($layoutfile);

        $rendered = ob_get_contents();

        ob_end_clean();

        return $rendered;

    }

    /**

     * Outputs the page's footer

     *

     * @return string HTML fragment

     */

    public function footer() {

        global $CFG, $DB, $PERF;

        $hook = new before_footer_html_generation($this);

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        $hook->add_html($this->container_end_all(true));

        $output = $hook->get_output();

        $footer = $this->opencontainers->pop('header/footer');

        if (debugging() and $DB and $DB->is_transaction_started()) {

            // TODO: MDL-20625 print warning - transaction will be rolled back

        }

        // Provide some performance info if required

        $performanceinfo = '';

        if (MDL_PERF || (!empty($CFG->perfdebug) && $CFG->perfdebug > 7)) {

            if (MDL_PERFTOFOOT || debugging() || (!empty($CFG->perfdebug) && $CFG->perfdebug > 7)) {

                if (NO_OUTPUT_BUFFERING) {

                    // If the output buffer was off then we render a placeholder and stream the

                    // performance debugging into it at the very end in the shutdown handler.

                    $PERF->perfdebugdeferred = true;

                    $performanceinfo .= html_writer::tag(

                        'div',

                        get_string('perfdebugdeferred', 'admin'),

                        [

                            'id' => 'perfdebugfooter',

                            'style' => 'min-height: 30em',

                        ]

                    );

                } else {

                    $perf = get_performance_info();

                    $performanceinfo = $perf['html'];