mirror of
https://github.com/moodle/moodle.git
synced 2025-07-26 08:50:30 +02:00
1145 lines
50 KiB
PHP
1145 lines
50 KiB
PHP
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
namespace core\navigation\views;
|
|
|
|
use navigation_node;
|
|
use url_select;
|
|
use settings_navigation;
|
|
|
|
/**
|
|
* Class secondary_navigation_view.
|
|
*
|
|
* The secondary navigation view is a stripped down tweaked version of the
|
|
* settings_navigation/navigation
|
|
*
|
|
* @package core
|
|
* @category navigation
|
|
* @copyright 2021 onwards Peter Dias
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class secondary extends view {
|
|
/** @var string $headertitle The header for this particular menu*/
|
|
public $headertitle;
|
|
|
|
/** @var int The maximum limit of navigation nodes displayed in the secondary navigation */
|
|
const MAX_DISPLAYED_NAV_NODES = 5;
|
|
|
|
/** @var navigation_node The course overflow node. */
|
|
protected $courseoverflownode = null;
|
|
|
|
/** @var string The key of the node to set as selected in the course overflow menu, if explicitly set by a page. */
|
|
protected $overflowselected = null;
|
|
|
|
/**
|
|
* Defines the default structure for the secondary nav in a course context.
|
|
*
|
|
* In a course context, we are curating nodes from the settingsnav and navigation objects.
|
|
* The following mapping construct specifies which object we are fetching it from, the type of the node, the key
|
|
* and in what order we want the node - defined as per the mockups.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function get_default_course_mapping(): array {
|
|
$nodes = [];
|
|
$nodes['settings'] = [
|
|
self::TYPE_CONTAINER => [
|
|
'coursereports' => 3,
|
|
'questionbank' => 4,
|
|
],
|
|
self::TYPE_SETTING => [
|
|
'editsettings' => 0,
|
|
'review' => 1.1,
|
|
'manageinstances' => 1.2,
|
|
'groups' => 1.3,
|
|
'override' => 1.4,
|
|
'roles' => 1.5,
|
|
'permissions' => 1.6,
|
|
'otherusers' => 1.7,
|
|
'gradebooksetup' => 2.1,
|
|
'outcomes' => 2.2,
|
|
'coursecompletion' => 6,
|
|
'coursebadges' => 7.1,
|
|
'newbadge' => 7.2,
|
|
'filtermanagement' => 9,
|
|
'unenrolself' => 10,
|
|
'coursetags' => 11,
|
|
'download' => 12,
|
|
'contextlocking' => 13,
|
|
],
|
|
];
|
|
$nodes['navigation'] = [
|
|
self::TYPE_CONTAINER => [
|
|
'participants' => 1,
|
|
],
|
|
self::TYPE_SETTING => [
|
|
'grades' => 2,
|
|
'badgesview' => 7,
|
|
'competencies' => 8,
|
|
],
|
|
self::TYPE_CUSTOM => [
|
|
'contentbank' => 5,
|
|
'participants' => 1, // In site home, 'participants' is classified differently.
|
|
],
|
|
];
|
|
|
|
return $nodes;
|
|
}
|
|
|
|
/**
|
|
* Defines the default structure for the secondary nav in a module context.
|
|
*
|
|
* In a module context, we are curating nodes from the settingsnav object.
|
|
* The following mapping construct specifies the type of the node, the key
|
|
* and in what order we want the node - defined as per the mockups.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function get_default_module_mapping(): array {
|
|
return [
|
|
self::TYPE_SETTING => [
|
|
'modedit' => 1,
|
|
"mod_{$this->page->activityname}_useroverrides" => 3, // Overrides are module specific.
|
|
"mod_{$this->page->activityname}_groupoverrides" => 4,
|
|
'roleassign' => 7.2,
|
|
'filtermanage' => 6,
|
|
'roleoverride' => 7,
|
|
'rolecheck' => 7.1,
|
|
'logreport' => 8,
|
|
'backup' => 9,
|
|
'restore' => 10,
|
|
'competencybreakdown' => 11,
|
|
'sendtomoodlenet' => 16,
|
|
],
|
|
self::TYPE_CUSTOM => [
|
|
'advgrading' => 2,
|
|
'contentbank' => 12,
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Defines the default structure for the secondary nav in a category context.
|
|
*
|
|
* In a category context, we are curating nodes from the settingsnav object.
|
|
* The following mapping construct specifies the type of the node, the key
|
|
* and in what order we want the node - defined as per the mockups.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function get_default_category_mapping(): array {
|
|
return [
|
|
self::TYPE_SETTING => [
|
|
'edit' => 1,
|
|
'permissions' => 2,
|
|
'roles' => 2.1,
|
|
'rolecheck' => 2.2,
|
|
]
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Define the keys of the course secondary nav nodes that should be forced into the "more" menu by default.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function get_default_category_more_menu_nodes(): array {
|
|
return ['addsubcat', 'roles', 'permissions', 'contentbank', 'cohort', 'filters', 'restorecourse'];
|
|
}
|
|
/**
|
|
* Define the keys of the course secondary nav nodes that should be forced into the "more" menu by default.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function get_default_course_more_menu_nodes(): array {
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Define the keys of the module secondary nav nodes that should be forced into the "more" menu by default.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function get_default_module_more_menu_nodes(): array {
|
|
return ['roleoverride', 'rolecheck', 'logreport', 'roleassign', 'filtermanage', 'backup', 'restore',
|
|
'competencybreakdown', "mod_{$this->page->activityname}_useroverrides",
|
|
"mod_{$this->page->activityname}_groupoverrides"];
|
|
}
|
|
|
|
/**
|
|
* Define the keys of the admin secondary nav nodes that should be forced into the "more" menu by default.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function get_default_admin_more_menu_nodes(): array {
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Initialise the view based navigation based on the current context.
|
|
*
|
|
* As part of the initial restructure, the secondary nav is only considered for the following pages:
|
|
* 1 - Site admin settings
|
|
* 2 - Course page - Does not include front_page which has the same context.
|
|
* 3 - Module page
|
|
*/
|
|
public function initialise(): void {
|
|
global $SITE;
|
|
|
|
if (during_initial_install() || $this->initialised) {
|
|
return;
|
|
}
|
|
$this->id = 'secondary_navigation';
|
|
$context = $this->context;
|
|
$this->headertitle = get_string('menu');
|
|
$defaultmoremenunodes = [];
|
|
$maxdisplayednodes = self::MAX_DISPLAYED_NAV_NODES;
|
|
|
|
switch ($context->contextlevel) {
|
|
case CONTEXT_COURSE:
|
|
$this->headertitle = get_string('courseheader');
|
|
if ($this->page->course->format === 'singleactivity') {
|
|
$this->load_single_activity_course_navigation();
|
|
} else {
|
|
$this->load_course_navigation();
|
|
$defaultmoremenunodes = $this->get_default_course_more_menu_nodes();
|
|
}
|
|
break;
|
|
case CONTEXT_MODULE:
|
|
$this->headertitle = get_string('activityheader');
|
|
if ($this->page->course->format === 'singleactivity') {
|
|
$this->load_single_activity_course_navigation();
|
|
} else {
|
|
$this->load_module_navigation($this->page->settingsnav);
|
|
$defaultmoremenunodes = $this->get_default_module_more_menu_nodes();
|
|
}
|
|
break;
|
|
case CONTEXT_COURSECAT:
|
|
$this->headertitle = get_string('categoryheader');
|
|
$this->load_category_navigation();
|
|
$defaultmoremenunodes = $this->get_default_category_more_menu_nodes();
|
|
break;
|
|
case CONTEXT_SYSTEM:
|
|
$this->headertitle = get_string('homeheader');
|
|
$this->load_admin_navigation();
|
|
// If the site administration navigation was generated after load_admin_navigation().
|
|
if ($this->has_children()) {
|
|
// Do not explicitly limit the number of navigation nodes displayed in the site administration
|
|
// navigation menu.
|
|
$maxdisplayednodes = null;
|
|
}
|
|
$defaultmoremenunodes = $this->get_default_admin_more_menu_nodes();
|
|
break;
|
|
}
|
|
|
|
$this->remove_unwanted_nodes($this);
|
|
|
|
// Don't need to show anything if only the view node is available. Remove it.
|
|
if ($this->children->count() == 1) {
|
|
$this->children->remove('modulepage');
|
|
}
|
|
// Force certain navigation nodes to be displayed in the "more" menu.
|
|
$this->force_nodes_into_more_menu($defaultmoremenunodes, $maxdisplayednodes);
|
|
// Search and set the active node.
|
|
$this->scan_for_active_node($this);
|
|
$this->initialised = true;
|
|
}
|
|
|
|
/**
|
|
* Returns a node with the action being from the first found child node that has an action (Recursive).
|
|
*
|
|
* @param navigation_node $node The part of the node tree we are checking.
|
|
* @param navigation_node $basenode The very first node to be used for the return.
|
|
* @return navigation_node|null
|
|
*/
|
|
protected function get_node_with_first_action(navigation_node $node, navigation_node $basenode): ?navigation_node {
|
|
$newnode = null;
|
|
if (!$node->has_children()) {
|
|
return null;
|
|
}
|
|
|
|
// Find the first child with an action and update the main node.
|
|
foreach ($node->children as $child) {
|
|
if ($child->has_action()) {
|
|
$newnode = $basenode;
|
|
$newnode->action = $child->action;
|
|
return $newnode;
|
|
}
|
|
}
|
|
if (is_null($newnode)) {
|
|
// Check for children and go again.
|
|
foreach ($node->children as $child) {
|
|
if ($child->has_children()) {
|
|
$newnode = $this->get_node_with_first_action($child, $basenode);
|
|
|
|
if (!is_null($newnode)) {
|
|
return $newnode;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Some nodes are containers only with no action. If this container has an action then nothing is done. If it does not have
|
|
* an action then a search is done through the children looking for the first node that has an action. This action is then given
|
|
* to the parent node that is initially provided as a parameter.
|
|
*
|
|
* @param navigation_node $node The navigation node that we want to ensure has an action tied to it.
|
|
* @return navigation_node The node intact with an action to use.
|
|
*/
|
|
protected function get_first_action_for_node(navigation_node $node): ?navigation_node {
|
|
// If the node does not have children and has no action then no further processing is needed.
|
|
$newnode = null;
|
|
if ($node->has_children() && !$node->has_action()) {
|
|
// We want to find the first child with an action.
|
|
// We want to check all children on this level before going further down.
|
|
// Note that new node gets changed here.
|
|
$newnode = $this->get_node_with_first_action($node, $node);
|
|
} else if ($node->has_action()) {
|
|
$newnode = $node;
|
|
}
|
|
return $newnode;
|
|
}
|
|
|
|
/**
|
|
* Recursive call to add all custom navigation nodes to secondary
|
|
*
|
|
* @param navigation_node $node The node which should be added to secondary
|
|
* @param navigation_node $basenode The original parent node
|
|
* @param navigation_node|null $root The parent node nodes are to be added/removed to.
|
|
* @param bool $forceadd Whether or not to bypass the external action check and force add all nodes
|
|
*/
|
|
protected function add_external_nodes_to_secondary(navigation_node $node, navigation_node $basenode,
|
|
?navigation_node $root = null, bool $forceadd = false) {
|
|
$root = $root ?? $this;
|
|
// Add the first node.
|
|
if ($node->has_action() && !$this->get($node->key)) {
|
|
$root->add_node(clone $node);
|
|
}
|
|
|
|
// If the node has an external action add all children to the secondary navigation.
|
|
if (!$node->has_internal_action() || $forceadd) {
|
|
if ($node->has_children()) {
|
|
foreach ($node->children as $child) {
|
|
if ($child->has_children()) {
|
|
$this->add_external_nodes_to_secondary($child, $basenode, $root, true);
|
|
} else if ($child->has_action() && !$this->get($child->key)) {
|
|
// Check whether the basenode matches a child's url.
|
|
// This would have happened in get_first_action_for_node.
|
|
// In these cases, we prefer the specific child content.
|
|
if ($basenode->has_action() && $basenode->action()->compare($child->action())) {
|
|
$root->children->remove($basenode->key, $basenode->type);
|
|
}
|
|
$root->add_node(clone $child);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a list of all expected nodes in the course administration.
|
|
*
|
|
* @return array An array of keys for navigation nodes in the course administration.
|
|
*/
|
|
protected function get_expected_course_admin_nodes(): array {
|
|
$expectednodes = [];
|
|
foreach ($this->get_default_course_mapping()['settings'] as $value) {
|
|
foreach ($value as $nodekey => $notused) {
|
|
$expectednodes[] = $nodekey;
|
|
}
|
|
}
|
|
foreach ($this->get_default_course_mapping()['navigation'] as $value) {
|
|
foreach ($value as $nodekey => $notused) {
|
|
$expectednodes[] = $nodekey;
|
|
}
|
|
}
|
|
$othernodes = ['users', 'gradeadmin', 'coursereports', 'coursebadges'];
|
|
$leftovercourseadminnodes = ['backup', 'restore', 'import', 'copy', 'reset'];
|
|
$expectednodes = array_merge($expectednodes, $othernodes);
|
|
$expectednodes = array_merge($expectednodes, $leftovercourseadminnodes);
|
|
return $expectednodes;
|
|
}
|
|
|
|
/**
|
|
* Load the course secondary navigation. Since we are sourcing all the info from existing objects that already do
|
|
* the relevant checks, we don't do it again here.
|
|
*
|
|
* @param navigation_node|null $rootnode The node where the course navigation nodes should be added into as children.
|
|
* If not explicitly defined, the nodes will be added to the secondary root
|
|
* node by default.
|
|
*/
|
|
protected function load_course_navigation(?navigation_node $rootnode = null): void {
|
|
global $SITE;
|
|
|
|
$rootnode = $rootnode ?? $this;
|
|
$course = $this->page->course;
|
|
// Initialise the main navigation and settings nav.
|
|
// It is important that this is done before we try anything.
|
|
$settingsnav = $this->page->settingsnav;
|
|
$navigation = $this->page->navigation;
|
|
|
|
if ($course->id == $SITE->id) {
|
|
$firstnodeidentifier = get_string('home'); // The first node in the site course nav is called 'Home'.
|
|
$frontpage = $settingsnav->get('frontpage'); // The site course nodes are children of a dedicated 'frontpage' node.
|
|
$settingsnav = $frontpage ?: $settingsnav;
|
|
$courseadminnode = $frontpage ?: null; // Custom nodes for the site course are also children of the 'frontpage' node.
|
|
} else {
|
|
$firstnodeidentifier = get_string('course'); // Regular courses have a first node called 'Course'.
|
|
$courseadminnode = $settingsnav->get('courseadmin'); // Custom nodes for regular courses live under 'courseadmin'.
|
|
}
|
|
|
|
// Add the known nodes from settings and navigation.
|
|
$nodes = $this->get_default_course_mapping();
|
|
$nodesordered = $this->get_leaf_nodes($settingsnav, $nodes['settings'] ?? []);
|
|
$nodesordered += $this->get_leaf_nodes($navigation, $nodes['navigation'] ?? []);
|
|
$this->add_ordered_nodes($nodesordered, $rootnode);
|
|
|
|
// Try to get any custom nodes defined by plugins, which may include containers.
|
|
if ($courseadminnode) {
|
|
$expectedcourseadmin = $this->get_expected_course_admin_nodes();
|
|
foreach ($courseadminnode->children as $other) {
|
|
if (array_search($other->key, $expectedcourseadmin, true) === false) {
|
|
$othernode = $this->get_first_action_for_node($other);
|
|
$recursivenode = $othernode && !$rootnode->get($othernode->key) ? $othernode : $other;
|
|
// Get the first node and check whether it's been added already.
|
|
// Also check if the first node is an external link. If it is, add all children.
|
|
$this->add_external_nodes_to_secondary($recursivenode, $recursivenode, $rootnode);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Move some nodes into a 'course reuse' node.
|
|
$overflownode = $this->get_course_overflow_nodes($rootnode);
|
|
if (!is_null($overflownode)) {
|
|
$actionnode = $this->get_first_action_for_node($overflownode);
|
|
if ($actionnode) {
|
|
// All additional nodes will be available under the 'Course reuse' page.
|
|
$text = get_string('coursereuse');
|
|
$rootnode->add($text, $actionnode->action, navigation_node::TYPE_COURSE, null, 'coursereuse',
|
|
new \pix_icon('t/edit', $text));
|
|
}
|
|
}
|
|
|
|
// Add the respective first node, provided there are other nodes included.
|
|
if (!empty($nodekeys = $rootnode->children->get_key_list())) {
|
|
$rootnode->add_node(
|
|
navigation_node::create($firstnodeidentifier, new \moodle_url('/course/view.php', ['id' => $course->id]),
|
|
self::TYPE_COURSE, null, 'coursehome'), reset($nodekeys)
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the overflow navigation nodes for the course administration category.
|
|
*
|
|
* @param navigation_node|null $rootnode The node from where the course overflow nodes should be obtained.
|
|
* If not explicitly defined, the nodes will be obtained from the secondary root
|
|
* node by default.
|
|
* @return navigation_node The course overflow nodes.
|
|
*/
|
|
protected function get_course_overflow_nodes(?navigation_node $rootnode = null): ?navigation_node {
|
|
global $SITE;
|
|
|
|
$rootnode = $rootnode ?? $this;
|
|
// This gets called twice on some pages, and so trying to create this navigation node twice results in no children being
|
|
// present the second time this is called.
|
|
if (isset($this->courseoverflownode)) {
|
|
return $this->courseoverflownode;
|
|
}
|
|
|
|
// Start with getting the base node for the front page or the course.
|
|
$node = null;
|
|
if ($this->page->course->id == $SITE->id) {
|
|
$node = $this->page->settingsnav->find('frontpage', navigation_node::TYPE_SETTING);
|
|
} else {
|
|
$node = $this->page->settingsnav->find('courseadmin', navigation_node::TYPE_COURSE);
|
|
}
|
|
$coursesettings = $node ? $node->get_children_key_list() : [];
|
|
$thissettings = $rootnode->get_children_key_list();
|
|
$diff = array_diff($coursesettings, $thissettings);
|
|
|
|
// Remove our specific created elements (user - participants, badges - coursebadges, grades - gradebooksetup,
|
|
// grades - outcomes).
|
|
$shortdiff = array_filter($diff, function($value) {
|
|
return !($value == 'users' || $value == 'coursebadges' || $value == 'gradebooksetup' ||
|
|
$value == 'outcomes');
|
|
});
|
|
|
|
// Permissions may be in play here that ultimately will show no overflow.
|
|
if (empty($shortdiff)) {
|
|
return null;
|
|
}
|
|
|
|
$firstitem = array_shift($shortdiff);
|
|
$navnode = $node->get($firstitem);
|
|
foreach ($shortdiff as $key) {
|
|
$courseadminnodes = $node->get($key);
|
|
if ($courseadminnodes) {
|
|
if ($courseadminnodes->parent->key == $node->key) {
|
|
$navnode->add_node($courseadminnodes);
|
|
}
|
|
}
|
|
}
|
|
$this->courseoverflownode = $navnode;
|
|
return $navnode;
|
|
|
|
}
|
|
|
|
/**
|
|
* Recursively looks for a match to the current page url.
|
|
*
|
|
* @param navigation_node $node The node to look through.
|
|
* @return navigation_node|null The node that matches this page's url.
|
|
*/
|
|
protected function nodes_match_current_url(navigation_node $node): ?navigation_node {
|
|
$pagenode = $this->page->url;
|
|
if ($node->has_action()) {
|
|
// Check this node first.
|
|
if ($node->action->compare($pagenode)) {
|
|
return $node;
|
|
}
|
|
}
|
|
if ($node->has_children()) {
|
|
foreach ($node->children as $child) {
|
|
$result = $this->nodes_match_current_url($child);
|
|
if ($result) {
|
|
return $result;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Recursively search a node and its children for a node matching the key string $key.
|
|
*
|
|
* @param navigation_node $node the navigation node to check.
|
|
* @param string $key the key of the node to match.
|
|
* @return navigation_node|null node if found, otherwise null.
|
|
*/
|
|
protected function node_matches_key_string(navigation_node $node, string $key): ?navigation_node {
|
|
if ($node->has_action()) {
|
|
// Check this node first.
|
|
if ($node->key == $key) {
|
|
return $node;
|
|
}
|
|
}
|
|
if ($node->has_children()) {
|
|
foreach ($node->children as $child) {
|
|
$result = $this->node_matches_key_string($child, $key);
|
|
if ($result) {
|
|
return $result;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Force a specific node in the 'coursereuse' course overflow to be selected, based on the provided node key.
|
|
*
|
|
* Normally, the selected node is determined by matching the page URL to the node URL. E.g. The page 'backup/restorefile.php'
|
|
* will match the "Restore" node which has a registered URL of 'backup/restorefile.php' because the URLs match.
|
|
*
|
|
* This method allows a page to choose a specific node to match, which is useful in cases where the page knows its URL won't
|
|
* match the node it needs to reside under. I.e. this permits several pages to 'share' the same overflow node. When the page
|
|
* knows the PAGE->url won't match the node URL, the page can simply say "I want to match the 'XXX' node".
|
|
*
|
|
* E.g.
|
|
* - The $PAGE->url is 'backup/restore.php' (this page is used during restores but isn't the main landing page for a restore)
|
|
* - The 'Restore' node in the overflow has a key of 'restore' and will only match 'backup/restorefile.php' by default (the
|
|
* main restore landing page).
|
|
* - The backup/restore.php page calls:
|
|
* $PAGE->secondarynav->set_overflow_selected_node(new moodle_url('restore');
|
|
* and when the page is loaded, the 'Restore' node be presented as the selected node.
|
|
*
|
|
* @param string $nodekey The string key of the overflow node to match.
|
|
*/
|
|
public function set_overflow_selected_node(string $nodekey): void {
|
|
$this->overflowselected = $nodekey;
|
|
}
|
|
|
|
/**
|
|
* Returns a url_select object with overflow navigation nodes.
|
|
* This looks to see if the current page is within the course administration, or some other page that requires an overflow
|
|
* select object.
|
|
*
|
|
* @return url_select|null The overflow menu data.
|
|
*/
|
|
public function get_overflow_menu_data(): ?url_select {
|
|
|
|
if (!$this->page->get_navigation_overflow_state()) {
|
|
return null;
|
|
}
|
|
|
|
$issingleactivitycourse = $this->page->course->format === 'singleactivity';
|
|
$rootnode = $issingleactivitycourse ? $this->find('course', self::TYPE_COURSE) : $this;
|
|
$activenode = $this->find_active_node();
|
|
$incourseadmin = false;
|
|
|
|
if (!$activenode || ($issingleactivitycourse && $activenode->key === 'course')) {
|
|
// Could be in the course admin section.
|
|
$courseadmin = $this->page->settingsnav->find('courseadmin', navigation_node::TYPE_COURSE);
|
|
if (!$courseadmin) {
|
|
return null;
|
|
}
|
|
|
|
$activenode = $courseadmin->find_active_node();
|
|
if (!$activenode) {
|
|
return null;
|
|
}
|
|
$incourseadmin = true;
|
|
}
|
|
|
|
if ($activenode->key === 'coursereuse' || $incourseadmin) {
|
|
$courseoverflownode = $this->get_course_overflow_nodes($rootnode);
|
|
if (is_null($courseoverflownode)) {
|
|
return null;
|
|
}
|
|
if ($incourseadmin) {
|
|
// Validate whether the active node is part of the expected course overflow nodes.
|
|
if (($activenode->key !== $courseoverflownode->key) &&
|
|
!$courseoverflownode->find($activenode->key, $activenode->type)) {
|
|
return null;
|
|
}
|
|
}
|
|
$menuarray = static::create_menu_element([$courseoverflownode]);
|
|
if ($activenode->key != 'coursereuse') {
|
|
$inmenu = false;
|
|
foreach ($menuarray as $key => $value) {
|
|
if ($this->page->url->out(false) == $key) {
|
|
$inmenu = true;
|
|
}
|
|
}
|
|
if (!$inmenu) {
|
|
return null;
|
|
}
|
|
}
|
|
// If the page has explicitly set the overflow node it would like selected, find and use that node.
|
|
if ($this->overflowselected) {
|
|
$selectedoverflownode = $this->node_matches_key_string($courseoverflownode, $this->overflowselected);
|
|
$selectedoverflownodeurl = $selectedoverflownode ? $selectedoverflownode->action->out(false) : null;
|
|
}
|
|
|
|
$menuselect = new url_select($menuarray, $selectedoverflownodeurl ?? $this->page->url, null);
|
|
$menuselect->set_label(get_string('browsecourseadminindex', 'course'), ['class' => 'sr-only']);
|
|
return $menuselect;
|
|
} else {
|
|
return $this->get_other_overflow_menu_data($activenode);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets overflow menu data for third party plugin settings.
|
|
*
|
|
* @param navigation_node $activenode The node to gather the children for to put into the overflow menu.
|
|
* @return url_select|null The overflow menu in a url_select object.
|
|
*/
|
|
protected function get_other_overflow_menu_data(navigation_node $activenode): ?url_select {
|
|
if (!$activenode->has_action()) {
|
|
return null;
|
|
}
|
|
|
|
if (!$activenode->has_children()) {
|
|
return null;
|
|
}
|
|
|
|
// If the setting is extending the course navigation then the page being redirected to should be in the course context.
|
|
// It was decided on the issue that put this code here that plugins that extend the course navigation should have the pages
|
|
// that are redirected to, be in the course context or module context depending on which callback was used.
|
|
// Third part plugins were checked to see if any existing plugins had settings in a system context and none were found.
|
|
// The request of third party developers is to keep their settings within the specified context.
|
|
if ($this->page->context->contextlevel != CONTEXT_COURSE
|
|
&& $this->page->context->contextlevel != CONTEXT_MODULE
|
|
&& $this->page->context->contextlevel != CONTEXT_COURSECAT) {
|
|
return null;
|
|
}
|
|
|
|
// These areas have their own code to retrieve added plugin navigation nodes.
|
|
if ($activenode->key == 'coursehome' || $activenode->key == 'questionbank' || $activenode->key == 'coursereports') {
|
|
return null;
|
|
}
|
|
|
|
$menunode = $this->page->settingsnav->find($activenode->key, null);
|
|
|
|
if (!$menunode instanceof navigation_node) {
|
|
return null;
|
|
}
|
|
// Loop through all children and try and find a match to the current url.
|
|
$matchednode = $this->nodes_match_current_url($menunode);
|
|
if (is_null($matchednode)) {
|
|
return null;
|
|
}
|
|
if (!isset($menunode) || !$menunode->has_children()) {
|
|
return null;
|
|
}
|
|
$selectdata = static::create_menu_element([$menunode], false);
|
|
$urlselect = new url_select($selectdata, $matchednode->action->out(false), null);
|
|
$urlselect->set_label(get_string('browsesettingindex', 'course'), ['class' => 'sr-only']);
|
|
return $urlselect;
|
|
}
|
|
|
|
/**
|
|
* Get the module's secondary navigation. This is based on settings_nav and would include plugin nodes added via
|
|
* '_extend_settings_navigation'.
|
|
* It populates the tree based on the nav mockup
|
|
*
|
|
* If nodes change, we will have to explicitly call the callback again.
|
|
*
|
|
* @param settings_navigation $settingsnav The settings navigation object related to the module page
|
|
* @param navigation_node|null $rootnode The node where the module navigation nodes should be added into as children.
|
|
* If not explicitly defined, the nodes will be added to the secondary root
|
|
* node by default.
|
|
*/
|
|
protected function load_module_navigation(settings_navigation $settingsnav, ?navigation_node $rootnode = null): void {
|
|
$rootnode = $rootnode ?? $this;
|
|
$mainnode = $settingsnav->find('modulesettings', self::TYPE_SETTING);
|
|
$nodes = $this->get_default_module_mapping();
|
|
|
|
if ($mainnode) {
|
|
$url = new \moodle_url('/mod/' . $settingsnav->get_page()->activityname . '/view.php',
|
|
['id' => $settingsnav->get_page()->cm->id]);
|
|
$setactive = $url->compare($settingsnav->get_page()->url, URL_MATCH_BASE);
|
|
$node = $rootnode->add(get_string('modulename', $settingsnav->get_page()->activityname), $url,
|
|
null, null, 'modulepage');
|
|
if ($setactive) {
|
|
$node->make_active();
|
|
}
|
|
// Add the initial nodes.
|
|
$nodesordered = $this->get_leaf_nodes($mainnode, $nodes);
|
|
$this->add_ordered_nodes($nodesordered, $rootnode);
|
|
|
|
// We have finished inserting the initial structure.
|
|
// Populate the menu with the rest of the nodes available.
|
|
$this->load_remaining_nodes($mainnode, $nodes, $rootnode);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load the course category navigation.
|
|
*/
|
|
protected function load_category_navigation(): void {
|
|
$settingsnav = $this->page->settingsnav;
|
|
$mainnode = $settingsnav->find('categorysettings', self::TYPE_CONTAINER);
|
|
$nodes = $this->get_default_category_mapping();
|
|
|
|
if ($mainnode) {
|
|
$url = new \moodle_url('/course/index.php', ['categoryid' => $this->context->instanceid]);
|
|
$this->add(get_string('category'), $url, self::TYPE_CONTAINER, null, 'categorymain');
|
|
|
|
// Add the initial nodes.
|
|
$nodesordered = $this->get_leaf_nodes($mainnode, $nodes);
|
|
$this->add_ordered_nodes($nodesordered);
|
|
|
|
// We have finished inserting the initial structure.
|
|
// Populate the menu with the rest of the nodes available.
|
|
$this->load_remaining_nodes($mainnode, $nodes);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load the site admin navigation
|
|
*/
|
|
protected function load_admin_navigation(): void {
|
|
global $PAGE, $SITE;
|
|
|
|
$settingsnav = $this->page->settingsnav;
|
|
$node = $settingsnav->find('root', self::TYPE_SITE_ADMIN);
|
|
// We need to know if we are on the main site admin search page. Here the navigation between tabs are done via
|
|
// anchors and page reload doesn't happen. On every nested admin settings page, the secondary nav needs to
|
|
// exist as links with anchors appended in order to redirect back to the admin search page and the corresponding
|
|
// tab. Note this value refers to being present on the page itself, before a search has been performed.
|
|
$isadminsearchpage = $PAGE->url->compare(new \moodle_url('/admin/search.php', ['query' => '']), URL_MATCH_PARAMS);
|
|
if ($node) {
|
|
$siteadminnode = $this->add(get_string('general'), "#link$node->key", null, null, 'siteadminnode');
|
|
if ($isadminsearchpage) {
|
|
$siteadminnode->action = false;
|
|
$siteadminnode->tab = "#link$node->key";
|
|
} else {
|
|
$siteadminnode->action = new \moodle_url("/admin/search.php", [], "link$node->key");
|
|
}
|
|
foreach ($node->children as $child) {
|
|
if ($child->display && !$child->is_short_branch()) {
|
|
// Mimic the current boost behaviour and pass down anchors for the tabs.
|
|
if ($isadminsearchpage) {
|
|
$child->action = false;
|
|
$child->tab = "#link$child->key";
|
|
} else {
|
|
$child->action = new \moodle_url("/admin/search.php", [], "link$child->key");
|
|
}
|
|
$this->add_node(clone $child);
|
|
} else {
|
|
$siteadminnode->add_node(clone $child);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the indexed nodes to the current view or a given node. The key should indicate it's position in the tree.
|
|
* Any sub nodes needs to be numbered appropriately, e.g. 3.1 would make the identified node be listed under #3 node.
|
|
*
|
|
* @param array $nodes An array of navigation nodes to be added.
|
|
* @param navigation_node|null $rootnode The node where the nodes should be added into as children. If not explicitly
|
|
* defined, the nodes will be added to the secondary root node by default.
|
|
*/
|
|
protected function add_ordered_nodes(array $nodes, ?navigation_node $rootnode = null): void {
|
|
$rootnode = $rootnode ?? $this;
|
|
ksort($nodes);
|
|
foreach ($nodes as $key => $node) {
|
|
// If the key is a string then we are assuming this is a nested element.
|
|
if (is_string($key)) {
|
|
$parentnode = $nodes[floor($key)] ?? null;
|
|
if ($parentnode) {
|
|
$parentnode->add_node(clone $node);
|
|
}
|
|
} else {
|
|
$rootnode->add_node(clone $node);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Find the remaining nodes that need to be loaded into secondary based on the current context or a given node.
|
|
*
|
|
* @param navigation_node $completenode The original node that we are sourcing information from
|
|
* @param array $nodesmap The map used to populate secondary nav in the given context
|
|
* @param navigation_node|null $rootnode The node where the remaining nodes should be added into as children. If not
|
|
* explicitly defined, the nodes will be added to the secondary root node by
|
|
* default.
|
|
*/
|
|
protected function load_remaining_nodes(navigation_node $completenode, array $nodesmap,
|
|
?navigation_node $rootnode = null): void {
|
|
$flattenednodes = [];
|
|
$rootnode = $rootnode ?? $this;
|
|
foreach ($nodesmap as $nodecontainer) {
|
|
$flattenednodes = array_merge(array_keys($nodecontainer), $flattenednodes);
|
|
}
|
|
|
|
$populatedkeys = $this->get_children_key_list();
|
|
$existingkeys = $completenode->get_children_key_list();
|
|
$leftover = array_diff($existingkeys, $populatedkeys);
|
|
foreach ($leftover as $key) {
|
|
if (!in_array($key, $flattenednodes, true) && $leftovernode = $completenode->get($key)) {
|
|
// Check for nodes with children and potentially no action to direct to.
|
|
if ($leftovernode->has_children()) {
|
|
$leftovernode = $this->get_first_action_for_node($leftovernode);
|
|
}
|
|
|
|
// We have found the first node with an action.
|
|
if ($leftovernode) {
|
|
$this->add_external_nodes_to_secondary($leftovernode, $leftovernode, $rootnode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Force certain secondary navigation nodes to be displayed in the "more" menu.
|
|
*
|
|
* @param array $defaultmoremenunodes Array with navigation node keys of the pre-defined nodes that
|
|
* should be added into the "more" menu by default
|
|
* @param int|null $maxdisplayednodes The maximum limit of navigation nodes displayed in the secondary navigation
|
|
*/
|
|
protected function force_nodes_into_more_menu(array $defaultmoremenunodes = [], ?int $maxdisplayednodes = null) {
|
|
// Counter of the navigation nodes that are initially displayed in the secondary nav
|
|
// (excludes the nodes from the "more" menu).
|
|
$displayednodescount = 0;
|
|
foreach ($this->children as $child) {
|
|
// Skip if the navigation node has been already forced into the "more" menu.
|
|
if ($child->forceintomoremenu) {
|
|
continue;
|
|
}
|
|
// If the navigation node is in the pre-defined list of nodes that should be added by default in the
|
|
// "more" menu or the maximum limit of displayed navigation nodes has been reached (if defined).
|
|
if (in_array($child->key, $defaultmoremenunodes) ||
|
|
(!is_null($maxdisplayednodes) && $displayednodescount >= $maxdisplayednodes)) {
|
|
// Force the node and its children into the "more" menu.
|
|
$child->set_force_into_more_menu(true);
|
|
continue;
|
|
}
|
|
$displayednodescount++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Recursively remove navigation nodes that should not be displayed in the secondary navigation.
|
|
*
|
|
* @param navigation_node $node The starting navigation node.
|
|
*/
|
|
protected function remove_unwanted_nodes(navigation_node $node) {
|
|
foreach ($node->children as $child) {
|
|
if (!$child->showinsecondarynavigation) {
|
|
$child->remove();
|
|
continue;
|
|
}
|
|
if (!empty($child->children)) {
|
|
$this->remove_unwanted_nodes($child);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Takes the given navigation nodes and searches for children and formats it all into an array in a format to be used by a
|
|
* url_select element.
|
|
*
|
|
* @param navigation_node[] $navigationnodes Navigation nodes to format into a menu.
|
|
* @param bool $forceheadings Whether the returned array should be forced to use headings.
|
|
* @return array|null A url select element for navigating through the navigation nodes.
|
|
*/
|
|
public static function create_menu_element(array $navigationnodes, bool $forceheadings = false): ?array {
|
|
if (empty($navigationnodes)) {
|
|
return null;
|
|
}
|
|
|
|
// If one item, do we put this into a url_select?
|
|
if (count($navigationnodes) < 2) {
|
|
// Check if there are children.
|
|
$navnode = array_shift($navigationnodes);
|
|
$menudata = [];
|
|
if (!$navnode->has_children()) {
|
|
// Just one item.
|
|
if (!$navnode->has_action()) {
|
|
return null;
|
|
}
|
|
$menudata[$navnode->action->out(false)] = static::format_node_text($navnode);
|
|
} else {
|
|
if (static::does_menu_need_headings($navnode) || $forceheadings) {
|
|
// Let's do headings.
|
|
$menudata = static::get_headings_nav_array($navnode);
|
|
} else {
|
|
// Simple flat nav.
|
|
$menudata = static::get_flat_nav_array($navnode);
|
|
}
|
|
}
|
|
return $menudata;
|
|
} else {
|
|
// We have more than one navigation node to handle. Put each node in it's own heading.
|
|
$menudata = [];
|
|
$titledata = [];
|
|
foreach ($navigationnodes as $navigationnode) {
|
|
if ($navigationnode->has_children()) {
|
|
$menuarray = [];
|
|
// Add a heading and flatten out everything else.
|
|
if ($navigationnode->has_action()) {
|
|
$menuarray[static::format_node_text($navigationnode)][$navigationnode->action->out(false)] =
|
|
static::format_node_text($navigationnode);
|
|
$menuarray[static::format_node_text($navigationnode)] += static::get_whole_tree_flat($navigationnode);
|
|
} else {
|
|
$menuarray[static::format_node_text($navigationnode)] = static::get_whole_tree_flat($navigationnode);
|
|
}
|
|
|
|
$titledata += $menuarray;
|
|
} else {
|
|
// Add with no heading.
|
|
if (!$navigationnode->has_action()) {
|
|
return null;
|
|
}
|
|
$menudata[$navigationnode->action->out(false)] = static::format_node_text($navigationnode);
|
|
}
|
|
}
|
|
$menudata += [$titledata];
|
|
return $menudata;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Recursively goes through the provided navigation node and returns a flat version.
|
|
*
|
|
* @param navigation_node $navigationnode The navigationnode.
|
|
* @return array The whole tree flat.
|
|
*/
|
|
protected static function get_whole_tree_flat(navigation_node $navigationnode): array {
|
|
$nodes = [];
|
|
foreach ($navigationnode->children as $child) {
|
|
if ($child->has_action()) {
|
|
$nodes[$child->action->out()] = $child->text;
|
|
}
|
|
if ($child->has_children()) {
|
|
$childnodes = static::get_whole_tree_flat($child);
|
|
$nodes = array_merge($nodes, $childnodes);
|
|
}
|
|
}
|
|
return $nodes;
|
|
}
|
|
|
|
/**
|
|
* Checks to see if the provided navigation node has children and determines if we want headings for a url select element.
|
|
*
|
|
* @param navigation_node $navigationnode The navigation node we are checking.
|
|
* @return bool Whether we want headings or not.
|
|
*/
|
|
protected static function does_menu_need_headings(navigation_node $navigationnode): bool {
|
|
if (!$navigationnode->has_children()) {
|
|
return false;
|
|
}
|
|
foreach ($navigationnode->children as $child) {
|
|
if ($child->has_children()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Takes the navigation node and returns it in a flat fashion. This is not recursive.
|
|
*
|
|
* @param navigation_node $navigationnode The navigation node that we want to format into an array in a flat structure.
|
|
* @return array The flat navigation array.
|
|
*/
|
|
protected static function get_flat_nav_array(navigation_node $navigationnode): array {
|
|
$menuarray = [];
|
|
if ($navigationnode->has_action()) {
|
|
$menuarray[$navigationnode->action->out(false)] = static::format_node_text($navigationnode);
|
|
}
|
|
|
|
foreach ($navigationnode->children as $child) {
|
|
if ($child->has_action()) {
|
|
$menuarray[$child->action->out(false)] = static::format_node_text($child);
|
|
}
|
|
}
|
|
return $menuarray;
|
|
}
|
|
|
|
/**
|
|
* For any navigation node that we have determined needs headings we return a more tree like array structure.
|
|
*
|
|
* @param navigation_node $navigationnode The navigation node to use for the formatted array structure.
|
|
* @return array The headings navigation array structure.
|
|
*/
|
|
protected static function get_headings_nav_array(navigation_node $navigationnode): array {
|
|
$menublock = [];
|
|
// We know that this single node has headings, so grab this for the first heading.
|
|
$firstheading = [];
|
|
if ($navigationnode->has_action()) {
|
|
$firstheading[static::format_node_text($navigationnode)][$navigationnode->action->out(false)] =
|
|
static::format_node_text($navigationnode);
|
|
$firstheading[static::format_node_text($navigationnode)] += static::get_more_child_nodes($navigationnode, $menublock);
|
|
} else {
|
|
$firstheading[static::format_node_text($navigationnode)] = static::get_more_child_nodes($navigationnode, $menublock);
|
|
}
|
|
return [$firstheading + $menublock];
|
|
}
|
|
|
|
/**
|
|
* Recursively goes and gets all children nodes.
|
|
*
|
|
* @param navigation_node $node The node to get the children of.
|
|
* @param array $menublock Used to put all child nodes in its own container.
|
|
* @return array The additional child nodes.
|
|
*/
|
|
protected static function get_more_child_nodes(navigation_node $node, array &$menublock): array {
|
|
$nodes = [];
|
|
foreach ($node->children as $child) {
|
|
if (!$child->has_children()) {
|
|
if (!$child->has_action()) {
|
|
continue;
|
|
}
|
|
$nodes[$child->action->out(false)] = static::format_node_text($child);
|
|
} else {
|
|
$newarray = [];
|
|
if ($child->has_action()) {
|
|
$newarray[static::format_node_text($child)][$child->action->out(false)] = static::format_node_text($child);
|
|
$newarray[static::format_node_text($child)] += static::get_more_child_nodes($child, $menublock);
|
|
} else {
|
|
$newarray[static::format_node_text($child)] = static::get_more_child_nodes($child, $menublock);
|
|
}
|
|
$menublock += $newarray;
|
|
}
|
|
}
|
|
return $nodes;
|
|
}
|
|
|
|
/**
|
|
* Returns the navigation node text in a string.
|
|
*
|
|
* @param navigation_node $navigationnode The navigationnode to return the text string of.
|
|
* @return string The navigation node text string.
|
|
*/
|
|
protected static function format_node_text(navigation_node $navigationnode): string {
|
|
return (is_a($navigationnode->text, 'lang_string')) ? $navigationnode->text->out() : $navigationnode->text;
|
|
}
|
|
|
|
/**
|
|
* Load the single activity course secondary navigation.
|
|
*/
|
|
protected function load_single_activity_course_navigation(): void {
|
|
$page = $this->page;
|
|
$course = $page->course;
|
|
|
|
// Create 'Course' navigation node.
|
|
$coursesecondarynode = navigation_node::create(get_string('course'), null, self::TYPE_COURSE, null, 'course');
|
|
$this->load_course_navigation($coursesecondarynode);
|
|
// Remove the unnecessary 'Course' child node generated in load_course_navigation().
|
|
$coursehomenode = $coursesecondarynode->find('coursehome', self::TYPE_COURSE);
|
|
if (!empty($coursehomenode)) {
|
|
$coursehomenode->remove();
|
|
}
|
|
|
|
// Add the 'Course' node to the secondary navigation only if this node has children nodes.
|
|
if (count($coursesecondarynode->children) > 0) {
|
|
$this->add_node($coursesecondarynode);
|
|
// Once all the items have been added to the 'Course' secondary navigation node, set the 'showchildreninsubmenu'
|
|
// property to true. This is required to force the template to output these items within a dropdown menu.
|
|
$coursesecondarynode->showchildreninsubmenu = true;
|
|
}
|
|
|
|
// Create 'Activity' navigation node.
|
|
$activitysecondarynode = navigation_node::create(get_string('activity'), null, self::TYPE_ACTIVITY, null, 'activity');
|
|
|
|
// We should display the module related navigation in the course context as well. Therefore, we need to
|
|
// re-initialize the page object and manually set the course module to the one that it is currently visible in
|
|
// the course in order to obtain the required module settings navigation.
|
|
if ($page->context instanceof \context_course) {
|
|
$this->page->set_secondary_active_tab($coursesecondarynode->key);
|
|
// Get the currently used module in the single activity course.
|
|
$module = current(array_filter(get_course_mods($course->id), function ($module) {
|
|
return $module->visible == 1;
|
|
}));
|
|
// If the default module for the single course format has not been set yet, skip displaying the module
|
|
// related navigation in the secondary navigation.
|
|
if (!$module) {
|
|
return;
|
|
}
|
|
$page = new \moodle_page();
|
|
$page->set_cm($module, $course);
|
|
$page->set_url(new \moodle_url('/mod/' . $page->activityname . '/view.php', ['id' => $page->cm->id]));
|
|
}
|
|
|
|
$this->load_module_navigation($page->settingsnav, $activitysecondarynode);
|
|
|
|
// Add the 'Activity' node to the secondary navigation only if this node has more that one child node.
|
|
if (count($activitysecondarynode->children) > 1) {
|
|
// Set the 'showchildreninsubmenu' property to true to later output the the module navigation items within
|
|
// a dropdown menu.
|
|
$activitysecondarynode->showchildreninsubmenu = true;
|
|
$this->add_node($activitysecondarynode);
|
|
if ($this->context instanceof \context_module) {
|
|
$this->page->set_secondary_active_tab($activitysecondarynode->key);
|
|
}
|
|
} else { // Otherwise, add the 'View activity' node to the secondary navigation.
|
|
$viewactivityurl = new \moodle_url('/mod/' . $page->activityname . '/view.php', ['id' => $page->cm->id]);
|
|
$this->add(get_string('modulename', $page->activityname), $viewactivityurl, null, null, 'modulepage');
|
|
if ($this->context instanceof \context_module) {
|
|
$this->page->set_secondary_active_tab('modulepage');
|
|
}
|
|
}
|
|
}
|
|
}
|