WebSVN – Moodle – Diff – /lib/navigationlib.php

      * @param string|int $key
      * @param pix_icon $icon
      * @return navigation_node
      */
     public static function create($text, $action=null, $type=self::TYPE_CUSTOM,
-            $shorttext=null, $key=null, pix_icon $icon=null) {
+            $shorttext=null, $key=null, ?pix_icon $icon=null) {
         if ($action && !($action instanceof moodle_url || $action instanceof action_link)) {
             debugging(
                 "It is required that the action provided be either an action_url|moodle_url." .
                 " Please update your definition.", E_NOTICE);
+        }
      * @param string $shorttext
      * @param string|int $key
      * @param pix_icon $icon
      * @return navigation_node
      */
-    public function add($text, $action=null, $type=self::TYPE_CUSTOM, $shorttext=null, $key=null, pix_icon $icon=null) {
+    public function add($text, $action=null, $type=self::TYPE_CUSTOM, $shorttext=null, $key=null, ?pix_icon $icon=null) {
         if ($action && is_string($action)) {
             $action = new moodle_url($action);
+        }
         // Create child node
         $childnode = self::create($text, $action, $type, $shorttext, $key, $icon);
      * @param array $typestohide Optional. An array of node types that should be hidden.
      *      If null all nodes will be hidden.
      *      If an array is given then nodes will only be hidden if their type mtatches an element in the array.
      *          e.g. array(navigation_node::TYPE_COURSE) would hide only course nodes.
      */
-    public function hide(array $typestohide = null) {
+    public function hide(?array $typestohide = null) {
         if ($typestohide === null || in_array($this->type, $typestohide)) {
             $this->display = false;
             if ($this->has_children()) {
                 foreach ($this->children as $child) {
                     $child->hide($typestohide);
                     'contextlocking',
                      new pix_icon($lockicon, '')
                 );
+            }
+        }
+    }
+    /**
+     * Reset all static data.
+     *
+     * @throws coding_exception if called outside of a unit test
+     */
+    public static function reset_all_data(): void {
+        if (!defined('PHPUNIT_TEST') || !PHPUNIT_TEST) {
+            throw new coding_exception('Resetting all data is not allowed outside of PHPUnit tests.');
+        }
+        self::$fullmeurl = null;
+        self::$autofindactive = true;
         self::$loadadmintree = false;
+    }
+}
         if (during_initial_install()) {
             return;
+        }
         $homepage = get_home_page();
-        if ($homepage == HOMEPAGE_SITE) {
+        if ($homepage == HOMEPAGE_MY) {
-            // We are using the site home for the root element.
+            // We are using the users my moodle for the root element.
             $properties = array(
-                'key' => 'home',
+                'key' => 'myhome',
                 'type' => navigation_node::TYPE_SYSTEM,
-                'text' => get_string('home'),
+                'text' => get_string('myhome'),
-                'action' => new moodle_url('/'),
+                'action' => new moodle_url('/my/'),
-                'icon' => new pix_icon('i/home', '')
+                'icon' => new pix_icon('i/dashboard', ''),
             );
         } else if ($homepage == HOMEPAGE_MYCOURSES) {
             // We are using the user's course summary page for the root element.
             $properties = array(
                 'text' => get_string('mycourses'),
                 'action' => new moodle_url('/my/courses.php'),
                 'icon' => new pix_icon('i/course', '')
             );
         } else {
-            // We are using the users my moodle for the root element.
+            // We are using the site home for the root element.
             $properties = array(
-                'key' => 'myhome',
+                'key' => 'home',
                 'type' => navigation_node::TYPE_SYSTEM,
-                'text' => get_string('myhome'),
+                'text' => get_string('home'),
-                'action' => new moodle_url('/my/'),
+                'action' => new moodle_url('/'),
-                'icon' => new pix_icon('i/dashboard', '')
+                'icon' => new pix_icon('i/home', ''),
             );
+        }
         // Use the parents constructor.... good good reuse
             $activity = $coursenode->find($cm->id, self::TYPE_ACTIVITY);
             if (empty($activity)) {
                 $activity = $this->load_stealth_activity($coursenode, get_fast_modinfo($course));
+            }
+        }
-   }
+    }
     /**
      * Generates an array of sections and an array of activities for the given course.
+     *
         global $CFG;
         require_once($CFG->dirroot.'/course/lib.php');
         $modinfo = get_fast_modinfo($course);
+        $sections = $modinfo->get_section_info_all();
-        $sections = $modinfo->get_section_info_all();
+        $format = course_get_format($course);
         // For course formats using 'numsections' trim the sections list
-        $courseformatoptions = course_get_format($course)->get_format_options();
+        $courseformatoptions = $format->get_format_options();
         if (isset($courseformatoptions['numsections'])) {
             $sections = array_slice($sections, 0, $courseformatoptions['numsections']+1, true);
+        }
-        $activities = array();
+        $activities = [];
         foreach ($sections as $key => $section) {
             // Clone and unset summary to prevent $SESSION bloat (MDL-31802).
             $sections[$key] = clone($section);
             unset($sections[$key]->summary);
             $sections[$key]->hasactivites = false;
-            if (!array_key_exists($section->section, $modinfo->sections)) {
-                continue;
+            if (!array_key_exists($section->sectionnum, $modinfo->sections)) {
                 continue;
             foreach ($modinfo->sections[$section->section] as $cmid) {
-                $cm = $modinfo->cms[$cmid];
+            foreach ($section->get_sequence_cm_infos() as $cm) {
                 $activity = new stdClass;
                 $activity->id = $cm->id;
                 $activity->course = $course->id;
-                $activity->section = $section->section;
+                $activity->section = $section->sectionnum;
                 $activity->name = $cm->name;
                 $activity->icon = $cm->icon;
                 $activity->iconcomponent = $cm->iconcomponent;
                 $activity->hidden = (!$cm->visible);
+                $activity->modname = $cm->modname;
+                $activity->nodetype = navigation_node::NODETYPE_LEAF;
+                $activity->onclick = $cm->onclick;
+                $url = $cm->url;
+                // Activities witout url but with delegated section uses the section url.
+                $activity->delegatedsection = $cm->get_delegated_section_info();
+                if (empty($cm->url) && $activity->delegatedsection) {
+                    $url = $format->get_view_url(
+                        $activity->delegatedsection->sectionnum,
-                $activity->modname = $cm->modname;
+                        ['navigation' => true]
-                $activity->nodetype = navigation_node::NODETYPE_LEAF;
+                    );
                 $activity->onclick = $cm->onclick;
                 $url = $cm->url;
                 if (!$url) {
                     $activity->url = null;
                     $activity->display = false;
                 } else {
                     $activity->url = $url->out();
                     $activity->display = $cm->is_visible_on_course_page() ? true : false;
                     if (self::module_extends_navigation($cm->modname)) {
                         $activity->nodetype = navigation_node::NODETYPE_BRANCH;
+                    }
+                }
-                $activities[$cmid] = $activity;
+                $activities[$cm->id] = $activity;
                 if ($activity->display) {
                     $sections[$key]->hasactivites = true;
+                }
+            }
+        }
         global $CFG, $DB, $USER, $SITE;
         require_once($CFG->dirroot.'/course/lib.php');
         list($sections, $activities) = $this->generate_sections_and_activities($course);
-        $navigationsections = array();
-        foreach ($sections as $sectionid => $section) {
+        $navigationsections = [];
-            $section = clone($section);
+        foreach ($sections as $sectionid => $section) {
-            if ($course->id == $SITE->id) {
-                $this->load_section_activities($coursenode, $section->section, $activities);
-            } else {
-                if (!$section->uservisible || (!$this->showemptysections &&
+            if ($course->id == $SITE->id) {
-                        !$section->hasactivites && $this->includesectionnum !== $section->section)) {
+                $this->load_section_activities_navigation($coursenode, $section, $activities);
+                continue;
+            }
-                    continue;
+            if (
+                !$section->uservisible
-                }
+                || (
+                    !$this->showemptysections
+                    && !$section->hasactivites
+                    && $this->includesectionnum !== $section->section
+                )
-                $sectionname = get_section_name($course, $section);
+            ) {
-                $url = course_get_url($course, $section->section, array('navigation' => true));
+                continue;
-                $sectionnode = $coursenode->add($sectionname, $url, navigation_node::TYPE_SECTION,
-                    null, $section->id, new pix_icon('i/section', ''));
-                $sectionnode->nodetype = navigation_node::NODETYPE_BRANCH;
-                $sectionnode->hidden = (!$section->visible || !$section->available);
+            }
-                $sectionnode->add_attribute('data-section-name-for', $section->id);
                 if ($this->includesectionnum !== false && $this->includesectionnum == $section->section) {
+            // Delegated sections are added from the activity node.
+            if ($section->get_component_instance()) {
+                continue;
+            }
+            $navigationsections[$sectionid] = $this->load_section_navigation(
-                    $this->load_section_activities($sectionnode, $section->section, $activities);
+                parentnode: $coursenode,
                 section: $section,
-                $navigationsections[$sectionid] = $section;
+                activitiesdata: $activities,
             );
+        }
+        return $navigationsections;
+    }
+    /**
+     * Returns true if the section is included in the breadcrumb.
+     *
+     * @param section_info $section
+     * @param moodle_url|null $sectionurl
+     * @return bool
+     */
+    protected function is_section_in_breadcrumb(section_info $section, ?moodle_url $sectionurl): bool {
+        // Ajax requests uses includesectionnum as param.
+        if ($this->includesectionnum !== false && $this->includesectionnum == $section->sectionnum) {
+            return true;
+        }
+        // If we are in a section page, we need to check for any child section.
+        $checkchildrenurls = false;
+        $format = null;
+        if ($sectionurl && $this->page->url->compare($sectionurl, URL_MATCH_BASE)) {
+            $checkchildrenurls = true;
+            $format = course_get_format($section->course);
+        }
+        // Activities can have delegated sections that acts as a child section.
+        foreach ($section->get_sequence_cm_infos() as $cm) {
+            $delegatedsection = $cm->get_delegated_section_info();
+            if (!$delegatedsection) {
+                continue;
+            }
+            // Check if the child node is requested via Ajax.
+            if ($this->includesectionnum == $delegatedsection->sectionnum) {
+                return true;
+            }
+            if ($checkchildrenurls) {
+                $childurl = $format->get_view_url($delegatedsection, ['navigation' => true]);
+                if ($childurl && $this->page->url->compare($childurl, URL_MATCH_EXACT)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Loads a section into the navigation structure.
+     *
+     * @param navigation_node $parentnode
+     * @param section_info $section
+     * @param stdClass[] $activitiesdata Array of objects containing activities data indexed by cmid.
+     * @return navigation_node the section navigaiton node
+     */
+    public function load_section_navigation($parentnode, $section, $activitiesdata): navigation_node {
+        $format = course_get_format($section->course);
+        $sectionname = $format->get_section_name($section);
+        $url = $format->get_view_url($section, ['navigation' => true]);
+        $sectionnode = $parentnode->add(
+            text: $sectionname,
+            action: $url,
+            type: navigation_node::TYPE_SECTION,
+            key: $section->id,
+            icon: new pix_icon('i/section', ''),
+        );
+        $sectionnode->nodetype = navigation_node::NODETYPE_BRANCH;
+        $sectionnode->hidden = (!$section->visible || !$section->available);
+        $sectionnode->add_attribute('data-section-name-for', $section->id);
+        // Sections content are usually loaded via ajax but the sections from the requested breadcrumb.
+        if ($this->is_section_in_breadcrumb($section, $url)) {
+            $this->load_section_activities_navigation($sectionnode, $section, $activitiesdata);
         }
+        return $sectionnode;
+    }
-        return $navigationsections;
+    /**
      * Loads the activities for a section into the navigation structure.
+     *
-    /**
-     * Loads all of the activities for a section into the navigation structure.
+     * This method is called from global_navigation::load_section_navigation(),
-     *
-     * @param navigation_node $sectionnode
+     * It is not intended to be called directly.
-     * @param int $sectionnumber
+     *
+     * @param navigation_node $sectionnode
+     * @param section_info $section
+     * @param stdClass[] $activitiesdata Array of objects containing activities data indexed by cmid.
+     */
-     * @param array $activities An array of activites as returned by {@link global_navigation::generate_sections_and_activities()}
+    protected function load_section_activities_navigation(
-     * @param stdClass $course The course object the section and activities relate to.
-     * @return array Array of activity nodes
-     */
+        navigation_node $sectionnode,
-    protected function load_section_activities(navigation_node $sectionnode, $sectionnumber, array $activities, $course = null) {
+        section_info $section,
-        global $CFG, $SITE;
+        array $activitiesdata
-        // A static counter for JS function naming
+    ): array {
-        static $legacyonclickcounter = 0;
+        global $CFG, $SITE;
-        $activitynodes = array();
-        if (empty($activities)) {
-            return $activitynodes;
-        }
+        $activitynodes = [];
-        if (!is_object($course)) {
+        if (empty($activitiesdata)) {
+            return $activitynodes;
-            $activity = reset($activities);
+        }
+        foreach ($section->get_sequence_cm_infos() as $cm) {
+            $activitydata = $activitiesdata[$cm->id];
             $courseid = $activity->course;
-        } else {
+            // If activity is a delegated section, load a section node instead of the activity one.
-            $courseid = $course->id;
-        }
-        $showactivities = ($courseid != $SITE->id || !empty($CFG->navshowfrontpagemods));
-        foreach ($activities as $activity) {
-            if ($activity->section != $sectionnumber) {
-                continue;
-            }
-            if ($activity->icon) {
-                $icon = new pix_icon($activity->icon, get_string('modulename', $activity->modname), $activity->iconcomponent);
-            } else {
-                $icon = new pix_icon('monologo', get_string('modulename', $activity->modname), $activity->modname);
-            }
-            // Prepare the default name and url for the node
-            $displaycontext = \context_helper::get_navigation_filter_context(context_module::instance($activity->id));
-            $activityname = format_string($activity->name, true, ['context' => $displaycontext]);
-            $action = new moodle_url($activity->url);
-            // Check if the onclick property is set (puke!)
-            if (!empty($activity->onclick)) {
-                // Increment the counter so that we have a unique number.
-                $legacyonclickcounter++;
-                // Generate the function name we will use
-                $functionname = 'legacy_activity_onclick_handler_'.$legacyonclickcounter;
-                $propogrationhandler = '';
-                // Check if we need to cancel propogation. Remember inline onclick
-                // events would return false if they wanted to prevent propogation and the
-                // default action.
-                if (strpos($activity->onclick, 'return false')) {
-                    $propogrationhandler = 'e.halt();';
-                }
-                // Decode the onclick - it has already been encoded for display (puke)
+            if ($activitydata->delegatedsection) {
-                $onclick = htmlspecialchars_decode($activity->onclick, ENT_QUOTES);
-                // Build the JS function the click event will call
-                $jscode = "function {$functionname}(e) { $propogrationhandler $onclick }";
-                $this->page->requires->js_amd_inline($jscode);
-                // Override the default url with the new action link
-                $action = new action_link($action, $activityname, new component_action('click', $functionname));
+                $activitynodes[$activitydata->id] = $this->load_section_navigation(
                     parentnode: $sectionnode,
                     section: $activitydata->delegatedsection,
+                    activitiesdata: $activitiesdata,
+                );
+                continue;
+            }
+            $activitynodes[$activitydata->id] = $this->load_activity_navigation($sectionnode, $activitydata);
+        }
+        return $activitynodes;
+    }
+    /**
+     * Loads an activity into the navigation structure.
+     *
+     * This method is called from global_navigation::load_section_activities_navigation(),
+     * It is not intended to be called directly.
+     *
+     * @param navigation_node $sectionnode
+     * @param stdClass $activitydata The acitivy navigation data generated from generate_sections_and_activities
+     * @return navigation_node
+     */
+    protected function load_activity_navigation(
+        navigation_node $sectionnode,
+        stdClass $activitydata,
+    ): navigation_node {
+        global $SITE, $CFG;
+        $showactivities = ($activitydata->course != $SITE->id || !empty($CFG->navshowfrontpagemods));
+        $icon = new pix_icon(
+            $activitydata->icon ?: 'monologo',
+            get_string('modulename', $activitydata->modname),
+            $activitydata->icon ? $activitydata->iconcomponent : $activitydata->modname,
+        );
+        // Prepare the default name and url for the node.
+        $displaycontext = \context_helper::get_navigation_filter_context(context_module::instance($activitydata->id));
+        $activityname = format_string($activitydata->name, true, ['context' => $displaycontext]);
+        $activitynode = $sectionnode->add(
+            text: $activityname,
+            action: $this->get_activity_action($activitydata, $activityname),
+            type: navigation_node::TYPE_ACTIVITY,
+            key: $activitydata->id,
+            icon: $icon,
+        );
+        $activitynode->title(get_string('modulename', $activitydata->modname));
+        $activitynode->hidden = $activitydata->hidden;
+        $activitynode->display = $showactivities && $activitydata->display;
+        $activitynode->nodetype = $activitydata->nodetype;
+        return $activitynode;
+    }
+    /**
+     * Returns the action for the activity.
+     *
+     * @param stdClass $activitydata The acitivy navigation data generated from generate_sections_and_activities
+     * @param string $activityname
+     * @return moodle_url|action_link
+     */
+    protected function get_activity_action(stdClass $activitydata, string $activityname): moodle_url|action_link {
+        // A static counter for JS function naming.
+        static $legacyonclickcounter = 0;
+        $action = new moodle_url($activitydata->url);
+        // Check if the onclick property is set (puke!).
+        if (!empty($activitydata->onclick)) {
+            // Increment the counter so that we have a unique number.
+            $legacyonclickcounter++;
+            // Generate the function name we will use.
+            $functionname = 'legacy_activity_onclick_handler_' . $legacyonclickcounter;
+            $propogrationhandler = '';
+            // Check if we need to cancel propogation. Remember inline onclick
+            // events would return false if they wanted to prevent propogation and the
+            // default action.
+            if (strpos($activitydata->onclick, 'return false')) {
+                $propogrationhandler = 'e.halt();';
+            }
+            // Decode the onclick - it has already been encoded for display (puke).
+            $onclick = htmlspecialchars_decode($activitydata->onclick, ENT_QUOTES);
+            // Build the JS function the click event will call.
+            $jscode = "function {$functionname}(e) { $propogrationhandler $onclick }";
+            $this->page->requires->js_amd_inline($jscode);
+            // Override the default url with the new action link.
+            $action = new action_link($action, $activityname, new component_action('click', $functionname));
+        }
+        return $action;
+    }
+    /**
+     * Loads all of the activities for a section into the navigation structure.
+     *
+     * @param navigation_node $sectionnode
+     * @param int $sectionnumber
+     * @param array $activities An array of activites as returned by {@link global_navigation::generate_sections_and_activities()}
+     * @param stdClass $course The course object the section and activities relate to.
+     * @return array Array of activity nodes
+     */
+    #[\core\attribute\deprecated(
+        replacement: 'load_section_activities_navigation',
+        since: '4.5',
+        mdl: 'MDL-82845',
+    )]
+    protected function load_section_activities(navigation_node $sectionnode, $sectionnumber, array $activities, $course = null) {
-            $activitynode = $sectionnode->add($activityname, $action, navigation_node::TYPE_ACTIVITY, null, $activity->id, $icon);
+        \core\deprecation::emit_deprecation([self::class, __FUNCTION__]);
-            $activitynode->title(get_string('modulename', $activity->modname));
+        if (!is_object($course)) {
-            $activitynode->hidden = $activity->hidden;
+            $activity = reset($activities);
-            $activitynode->display = $showactivities && $activity->display;
+            $courseid = $activity->course;
-            $activitynode->nodetype = $activity->nodetype;
+        } else {
                 } else {
                     $usernode->add(get_string('viewprofile'), new moodle_url('/user/view.php', $baseargs));
+                }
+            }
-            if (!empty($CFG->navadduserpostslinks)) {
-                // Add nodes for forum posts and discussions if the user can view either or both
-                // There are no capability checks here as the content of the page is based
-                // purely on the forums the current user has access too.
-                $forumtab = $usernode->add(get_string('forumposts', 'forum'));
-                $forumtab->add(get_string('posts', 'forum'), new moodle_url('/mod/forum/user.php', $baseargs));
-                $forumtab->add(get_string('discussions', 'forum'), new moodle_url('/mod/forum/user.php',
-                        array_merge($baseargs, array('mode' => 'discussions'))));
-            }
             // Add blog nodes.
             if (!empty($CFG->enableblogs)) {
                 if (!$this->cache->cached('userblogoptions'.$user->id)) {
                     require_once($CFG->dirroot.'/blog/lib.php');
             $siteparticipantsnode->remove();
+        }
         // Badges.
         if ($navoptions->badges) {
-            $url = new moodle_url('/badges/view.php', array('type' => 2, 'id' => $course->id));
+            $url = new moodle_url('/badges/index.php', ['type' => 2, 'id' => $course->id]);
             $coursenode->add(get_string('coursebadges', 'badges'), $url,
                     navigation_node::TYPE_SETTING, null, 'badgesview',
             ]);
             $coursenode->add(get_string('communication', 'communication'), $url,
                 navigation_node::TYPE_SETTING, null, 'communication');
+        }
+        if ($navoptions->overview) {
+            $coursenode->add(
+                text: get_string('activities'),
+                action: new moodle_url('/course/overview.php', ['id' => $course->id]),
+                type: self::TYPE_CONTAINER,
+                key: 'courseoverview',
+                icon: new pix_icon('i/info', ''),
+            );
+        }
         return true;
+    }
     /**
      * This generates the structure of the course that won't be generated when
         $filterselect = 0;
         // Badges.
         if ($navoptions->badges) {
-            $url = new moodle_url($CFG->wwwroot . '/badges/view.php', array('type' => 1));
+            $url = new moodle_url($CFG->wwwroot . '/badges/index.php', ['type' => 1]);
             $coursenode->add(get_string('sitebadges', 'badges'), $url, navigation_node::TYPE_CUSTOM);
+        }
      * @param string $shorttext
      * @param string|int $key A key to identify this node with. Key + type is unique to a parent.
      * @param pix_icon $icon An optional icon to use for this node.
      * @return navigation_node
      */
-    public function add($text, $action=null, $type=self::TYPE_CUSTOM, $shorttext=null, $key=null, pix_icon $icon=null) {
+    public function add($text, $action=null, $type=self::TYPE_CUSTOM, $shorttext=null, $key=null, ?pix_icon $icon=null) {
         if ($this->content !== null) {
             debugging('Nav bar items must be printed before $OUTPUT->header() has been called', DEBUG_DEVELOPER);
+        }
      * @param string $shorttext
      * @param string|int $key A key to identify this node with. Key + type is unique to a parent.
      * @param pix_icon $icon An optional icon to use for this node.
      * @return navigation_node
      */
-    public function prepend($text, $action=null, $type=self::TYPE_CUSTOM, $shorttext=null, $key=null, pix_icon $icon=null) {
+    public function prepend($text, $action=null, $type=self::TYPE_CUSTOM, $shorttext=null, $key=null, ?pix_icon $icon=null) {
         if ($this->content !== null) {
             debugging('Nav bar items must be printed before $OUTPUT->header() has been called', DEBUG_DEVELOPER);
+        }
         // Properties array used when creating the new navigation node.
         $itemarray = array(
      * @param string $shorttext
      * @param string|int $key a key to access the node by.
      * @param pix_icon $icon An icon that appears next to the node.
      * @return navigation_node with the new node added to it.
      */
-    public function add($text, $url=null, $type=null, $shorttext=null, $key=null, pix_icon $icon=null) {
+    public function add($text, $url=null, $type=null, $shorttext=null, $key=null, ?pix_icon $icon=null) {
         $node = parent::add($text, $url, $type, $shorttext, $key, $icon);
         $node->add_class('root_node');
         return $node;
+    }
      * @param string $shorttext
      * @param string|int $key a key to access the node by.
      * @param pix_icon $icon An icon that appears next to the node.
      * @return navigation_node $node with the new node added to it.
      */
-    public function prepend($text, $url=null, $type=null, $shorttext=null, $key=null, pix_icon $icon=null) {
+    public function prepend($text, $url=null, $type=null, $shorttext=null, $key=null, ?pix_icon $icon=null) {
         $children = $this->children;
         $childrenclass = get_class($children);
         $this->children = new $childrenclass;
         $node = $this->add($text, $url, $type, $shorttext, $key, $icon);
         foreach ($children as $child) {
      *      navigation tree
      * @param part_of_admin_tree $adminbranch The branch to add, if null generate the admin
      *      tree and start at the beginning
      * @return mixed A key to access the admin tree by
      */
-    protected function load_administration_settings(navigation_node $referencebranch=null, part_of_admin_tree $adminbranch=null) {
+    protected function load_administration_settings(?navigation_node $referencebranch=null, ?part_of_admin_tree $adminbranch=null) {
         global $CFG;
         // Check if we are just starting to generate this navigation.
             $coursenode->add(get_string('coursecompletion', 'completion'), $url, self::TYPE_SETTING, null, 'coursecompletion',
                              new pix_icon('i/settings', ''));
+        }
+        if (!$adminoptions->update && $adminoptions->tags) {
+            $url = \core\router\util::get_path_for_callable([
+                \core_course\route\controller\tags_controller::class,
-        if (!$adminoptions->update && $adminoptions->tags) {
+                'administer_tags',
-            $url = new moodle_url('/course/tags.php', array('id' => $course->id));
+            ], ['course' => $course->id]);
             $coursenode->add(get_string('coursetags', 'tag'), $url, self::TYPE_SETTING, null, 'coursetags', new pix_icon('i/settings', ''));
             $coursenode->get('coursetags')->set_force_into_more_menu();
+        }
             if (!$reportnav->has_children()) {
                 $reportnav->remove();
+            }
+        }
+        // Grade penalty navigation.
+        \core_grades\penalty_manager::extend_navigation_course($coursenode, $course, $coursecontext);
         // Check if we can view the gradebook's setup page.
         if ($adminoptions->gradebook) {
             $url = new moodle_url('/grade/edit/tree/index.php', array('id' => $course->id));
             $coursenode->add(get_string('gradebooksetup', 'grades'), $url, self::TYPE_SETTING,
             badges_add_course_navigation($coursenode, $course);
+        }
         // Questions
+        require_once($CFG->libdir . '/questionlib.php');
-        require_once($CFG->libdir . '/questionlib.php');
+        $baseurl = \core_question\local\bank\question_bank_helper::get_url_for_qbank_list($course->id);
-        question_extend_settings_navigation($coursenode, $coursecontext)->trim_if_empty();
+        question_extend_settings_navigation($coursenode, $coursecontext, $baseurl)->trim_if_empty();
         if ($adminoptions->update) {
             // Repository Instances
+        }
         // Let plugins hook into course navigation.
         $pluginsfunction = get_plugins_with_function('extend_navigation_course', 'lib.php');
         foreach ($pluginsfunction as $plugintype => $plugins) {
-            // Ignore the report plugin as it was already loaded above.
+            // Ignore the report and gradepenalty plugins as they were already loaded above.
-            if ($plugintype == 'report') {
+            if ($plugintype == 'report' || $plugintype == 'gradepenalty') {
                 continue;
+            }
             foreach ($plugins as $pluginfunction) {
                 $pluginfunction($coursenode, $course, $coursecontext);
             // Add the user profile to the dashboard.
             $profilenode = $mainpage->add(get_string('profile'), new moodle_url('/user/profile.php',
-                    array('id' => $user->id)), self::TYPE_SETTING, null, 'myprofile');
-            if (!empty($CFG->navadduserpostslinks)) {
-                // Add nodes for forum posts and discussions if the user can view either or both
-                // There are no capability checks here as the content of the page is based
-                // purely on the forums the current user has access too.
-                $forumtab = $profilenode->add(get_string('forumposts', 'forum'));
-                $forumtab->add(get_string('posts', 'forum'), new moodle_url('/mod/forum/user.php', $baseargs), null, 'myposts');
-                $forumtab->add(get_string('discussions', 'forum'), new moodle_url('/mod/forum/user.php',
-                        array_merge($baseargs, array('mode' => 'discussions'))), null, 'mydiscussions');
                     array('id' => $user->id)), self::TYPE_SETTING, null, 'myprofile');
             // Add blog nodes.
             if (!empty($CFG->enableblogs)) {
                 if (!$this->cache->cached('userblogoptions'.$user->id)) {
+            }
+        }
         // Questions
+        require_once($CFG->libdir . '/questionlib.php');
-        require_once($CFG->libdir . '/questionlib.php');
+        $baseurl = \core_question\local\bank\question_bank_helper::get_url_for_qbank_list($course->id);
-        question_extend_settings_navigation($frontpage, $coursecontext)->trim_if_empty();
+        question_extend_settings_navigation($frontpage, $coursecontext, $baseurl)->trim_if_empty();
         // Manage files
         if ($adminoptions->files) {
+        }
+    }
+}
 /**
- * The cache class used by global navigation and settings navigation.
+ * The navigation_cache class is used for global and settings navigation data.
  *
- * It is basically an easy access point to session with a bit of smarts to make
- * sure that the information that is cached is valid still.
+ * It provides an easy access to the session cache with TTL of 1800 seconds.
+ *
  * Example use:
  * <code php>
  * if (!$cache->viewdiscussion()) {
  * @category  navigation
  * @copyright 2009 Sam Hemelryk
  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
 class navigation_cache {
-    /** @var int represents the time created */
+    /** @var cache_session The session cache instance */
-    protected $creation;
+    protected $cache;
-    /** @var array An array of session keys */
+    /** @var array The current cache area data */
-    protected $session;
+    protected $session = [];
     /**
-     * The string to use to segregate this particular cache. It can either be
+     * @var string A unique string to segregate this particular cache.
-     * unique to start a fresh cache or if you want to share a cache then make
+     * It can either be unique to start a fresh cache or shared to use an existing cache.
-     * it the string used in the original cache.
-     * @var string
      */
     protected $area;
-    /** @var int a time that the information will time out */
-    protected $timeout;
-    /** @var stdClass The current context */
-    protected $currentcontext;
     /** @var int cache time information */
+    #[\core\attribute\deprecated(null, since: '4.5', reason: 'This constant is no longer needed.', mdl: 'MDL-79628')]
     const CACHETIME = 0;
     /** @var int cache user id */
+    #[\core\attribute\deprecated(null, since: '4.5', reason: 'This constant is no longer needed.', mdl: 'MDL-79628')]
     const CACHEUSERID = 1;
     /** @var int cache value */
     const CACHEVALUE = 2;
-    /** @var null|array An array of navigation cache areas to expire on shutdown */
+    /** @var null|array An array of cache areas to expire on shutdown */
-    public static $volatilecaches;
+    public static $volatilecaches = null;
     /**
-     * Contructor for the cache. Requires two arguments
+     * Contructor for the cache. Requires a area string be passed in.
      *
-     * @param string $area The string to use to segregate this particular cache
-     *                it can either be unique to start a fresh cache or if you want
-     *                to share a cache then make it the string used in the original
-     *                cache
+     * @param string $area The unique string to segregate this particular cache.
-     * @param int $timeout The number of seconds to time the information out after
+     * @param int $timeout Deprecated since Moodle 4.5. The number of seconds to time the information out after
      */
-    public function __construct($area, $timeout=1800) {
+    public function __construct($area, $timeout = null) {
-        $this->creation = time();
+        if ($timeout !== null) {
-        $this->area = $area;
+            debugging(
-        $this->timeout = time() - $timeout;
+                'The timeout argument has been deprecated. Please remove it from your method calls.',
-        if (rand(0,100) === 0) {
+                DEBUG_DEVELOPER,
-            $this->garbage_collection();
+            );
+        }
+        global $USER;
+        $this->area = "user_{$USER->id}_{$area}";
         $this->cache = cache::make('core', 'navigation_cache');
+    }
     /**
-     * Used to set up the cache within the SESSION.
+     * Ensure the navigation cache is initialised
-     *
      * This is called for each access and ensure that we don't put anything into the session before
-     * it is required.
+     * This is called for each access and ensures that no data is put into the cache before it is required.
-     */
-    protected function ensure_session_cache_initialised() {
+     */
+    protected function ensure_navigation_cache_initialised() {
-        global $SESSION;
+        if (empty($this->session)) {
-        if (empty($this->session)) {
+            $this->session = $this->cache->get($this->area);
-            if (!isset($SESSION->navcache)) {
+            if (!is_array($this->session)) {
-                $SESSION->navcache = new stdClass;
-            }
-            if (!isset($SESSION->navcache->{$this->area})) {
-                $SESSION->navcache->{$this->area} = array();
                 $this->session = [];
             $this->session = &$SESSION->navcache->{$this->area}; // pointer to array, =& is correct here
+        }
     }
     /**
-     * Magic Method to retrieve something by simply calling using = cache->key
+     * Magic Method to retrieve a cached item by simply calling using = cache->key
+     *
-     * @param mixed $key The identifier for the information you want out again
+     * @param mixed $key The identifier for the cached information
-     * @return void|mixed Either void or what ever was put in
+     * @return mixed|void The cached information or void if not found
      */
     public function __get($key) {
         if (!$this->cached($key)) {
-            return;
             return;
         $information = $this->session[$key][self::CACHEVALUE];
-        return unserialize($information);
+        return unserialize($this->session[$key][self::CACHEVALUE]);
+    }
     /**
-     * Magic method that simply uses {@link set();} to store something in the cache
+     * Magic method that simply uses {@see navigation_cache::set()} to store an item in the cache
+     *
-     * @param string|int $key
+     * @param string|int $key The key to store the information against
-     * @param mixed $information
+     * @param mixed $information The information to cache
      */
     public function __set($key, $information) {
         $this->set($key, $information);
+    }
     /**
-     * Sets some information against the cache (session) for later retrieval
+     * Sets some information in the session cache for later retrieval
-     *
-     * @param string|int $key
+     *
-     * @param mixed $information
+     * @param string|int $key
-     */
+     * @param mixed $information
+     */
     public function set($key, $information) {
-        global $USER;
+        $this->ensure_navigation_cache_initialised();
-        $this->ensure_session_cache_initialised();
+        $information = serialize($information);
-        $information = serialize($information);
+        $this->session[$key] = [self::CACHEVALUE => $information];
-        $this->session[$key]= array(self::CACHETIME=>time(), self::CACHEUSERID=>$USER->id, self::CACHEVALUE=>$information);
+        $this->cache->set($this->area, $this->session);
     }
     /**
      * Check the existence of the identifier in the cache
-     *
-     * @param string|int $key
+     *
-     * @return bool
-     */
+     * @param string|int $key The identifier to check
-    public function cached($key) {
-        global $USER;
+     * @return bool True if the item exists in the cache, false otherwise
-        $this->ensure_session_cache_initialised();
+     */
-        if (!array_key_exists($key, $this->session) || !is_array($this->session[$key]) || $this->session[$key][self::CACHEUSERID]!=$USER->id || $this->session[$key][self::CACHETIME] < $this->timeout) {
+    public function cached($key) {
-            return false;
+        $this->ensure_navigation_cache_initialised();
         return isset($this->session[$key]) &&
-        return true;
+            is_array($this->session[$key]);
     }
     /**
      * Compare something to it's equivilant in the cache
+     *
-     * @param string $key
+     * @param string $key  The key to check
-     * @param mixed $value
+     * @param mixed $value The value to compare
      * @param bool $serialise Whether to serialise the value before comparison
      *              this should only be set to false if the value is already
      *              serialised
-     * @return bool If the value is the same false if it is not set or doesn't match
+     * @return bool True if the value is the same as the cached one, false otherwise
      */
     public function compare($key, $value, $serialise = true) {
-        if ($this->cached($key)) {
-            if ($serialise) {
-                $value = serialize($value);
+        if ($this->cached($key)) {
             if ($serialise) {
-            if ($this->session[$key][self::CACHEVALUE] === $value) {
+                $value = serialize($value);
                 return true;
-            }
+            return $this->session[$key][self::CACHEVALUE] === $value;
+        }
         return false;
-    }
-    /**
+    }
-     * Wipes the entire cache, good to force regeneration
+    /**
-     */
+     * Deletes the entire cache area, forcing a fresh cache to be created
-    public function clear() {
+     */
-        global $SESSION;
-        unset($SESSION->navcache);
-        $this->session = null;
-    }
-    /**
-     * Checks all cache entries and removes any that have expired, good ole cleanup
-     */
-    protected function garbage_collection() {
-        if (empty($this->session)) {
-            return true;
-        }
-        foreach ($this->session as $key=>$cachedinfo) {
-            if (is_array($cachedinfo) && $cachedinfo[self::CACHETIME]<$this->timeout) {
-                unset($this->session[$key]);
-            }
+    public function clear() {
         $this->cache->delete($this->area);
-    }
+        $this->session = [];
-    /**
      * Marks the cache as being volatile (likely to change)
-     *
+    /**
-     * Any caches marked as volatile will be destroyed at the on shutdown by
+     * Marks the cache as volatile (likely to change)
      * {@link navigation_node::destroy_volatile_caches()} which is registered
-     * as a shutdown function if any caches are marked as volatile.
+     * Any caches marked as volatile will be destroyed on shutdown by {@see navigation_node::destroy_volatile_caches()}
      *
-     * @param bool $setting True to destroy the cache false not too
+     * @param bool $setting True to mark the cache as volatile, false to remove the volatile flag
      */
     public function volatile($setting = true) {
-        if (self::$volatilecaches===null) {
+        if (self::$volatilecaches === null) {
-            self::$volatilecaches = array();
+            self::$volatilecaches = [];
+    }
     /**
      * Destroys all caches marked as volatile
      *
-     * This function is static and works in conjunction with the static volatilecaches
-     * property of navigation cache.
+     * This function is static and works with the static volatilecaches property of navigation cache.
-     * Because this function is static it manually resets the cached areas back to an
-     * empty array.
+     * It manually resets the cached areas back to an empty array.
      */
-    public static function destroy_volatile_caches() {
-        global $SESSION;
+    public static function destroy_volatile_caches() {
+        if (is_array(self::$volatilecaches) && count(self::$volatilecaches) > 0) {
-        if (is_array(self::$volatilecaches) && count(self::$volatilecaches)>0) {
+            $cache = cache::make('core', 'navigation_cache');
             foreach (self::$volatilecaches as $area) {
-                $SESSION->navcache->{$area} = array();
+                $cache->delete($area);
-            }
-        } else {
+            }
-            $SESSION->navcache = new stdClass;
+            self::$volatilecaches = null;
+        }
+    }

Proyectos de Subversion Moodle

(root)/lib/navigationlib.php – Rev 1 → 1441