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

     define('MAX_MODINFO_CACHE_SIZE', 10);
+}
 use core_courseformat\output\activitybadge;
+use core_courseformat\sectiondelegate;
-use core_courseformat\sectiondelegate;
+use core_courseformat\sectiondelegatemodule;
 /**
  * Information about a course that is cached in the course table 'modinfo' field (and then in
      * @var array
      */
     private $delegatedsections;
+    /**
+     * Index of sections delegated by course modules, indexed by course module instance.
+     * @var null|section_info[]
+     */
+    private ?array $delegatedbycm = null;
+    /**
+     * Contains the course content weights so they can be sorted accordingly.
+     *
+     * @var array|null
+     */
+    private ?array $weights = null;
     /**
      * User ID
      * @var int
      */
         'userid' => 'get_user_id',
         'sections' => 'get_sections',
         'cms' => 'get_cms',
         'instances' => 'get_instances',
         'groups' => 'get_groups_all',
+        'delegatedbycm' => 'get_sections_delegated_by_cm',
     );
     /**
      * Magic method getter
+        }
         return $this->instances[$modname];
+    }
+    /**
+     * Obtains a single instance of a particular module on this course.
+     *
+     * @param string $modname Name of module (not full frankenstyle) e.g. 'label'
+     * @param int $instanceid Instance id
+     * @param int $strictness Use IGNORE_MISSING to return null if not found, or MUST_EXIST to throw exception
+     * @return cm_info|null cm_info for the instance on this course or null if not found
+     * @throws moodle_exception If the instance is not found
+     */
+    public function get_instance_of(string $modname, int $instanceid, int $strictness = IGNORE_MISSING): ?cm_info {
+        if (empty($this->instances[$modname]) || empty($this->instances[$modname][$instanceid])) {
+            if ($strictness === IGNORE_MISSING) {
+                return null;
+            }
+            throw new moodle_exception('invalidmoduleid', 'error', '', $instanceid);
+        }
+        return $this->instances[$modname][$instanceid];
+    }
+    /**
+     * Sorts the given array of course modules according to the order they appear on the course page.
+     *
+     * @param cm_info[] $cms Array of cm_info objects to sort by reference
+     * @return void
+     */
+    public function sort_cm_array(array &$cms): void {
+        $weights = $this->get_content_weights();
+        uasort($cms, function ($a, $b) use ($weights) {
+            $weighta = $weights['cm' . $a->id] ?? PHP_INT_MAX;
+            $weightb = $weights['cm' . $b->id] ?? PHP_INT_MAX;
+            return $weighta <=> $weightb;
+        });
+    }
     /**
      * Groups that the current user belongs to organised by grouping id. Calculated on the first request.
      * @return int[][] array of grouping id => array of group id => group id. Includes grouping id 0 for 'all groups'
      */
     private function get_groups_all() {
         if (empty($this->delegatedsections)) {
             return $this->sectioninfobynum;
+        }
         $sections = [];
         foreach ($this->sectioninfobynum as $section) {
-            if (!$section->is_delegated()) {
+            if (!$section->get_component_instance()) {
                 $sections[$section->section] = $section;
+            }
+        }
         return $sections;
+    }
     public function has_delegated_sections(): bool {
         return !empty($this->delegatedsections);
+    }
+    /**
+     * Gets data about section delegated by course modules.
+     *
+     * @return section_info[] sections array indexed by course module ID
+     */
+    public function get_sections_delegated_by_cm(): array {
+        if (!is_null($this->delegatedbycm)) {
+            return $this->delegatedbycm;
+        }
+        $this->delegatedbycm = [];
+        foreach ($this->delegatedsections as $componentsections) {
+            foreach ($componentsections as $section) {
+                $delegateinstance = $section->get_component_instance();
+                // We only return sections delegated by course modules. Sections delegated to other
+                // types of components must implement their own methods to get the section.
+                if (!$delegateinstance || !($delegateinstance instanceof sectiondelegatemodule)) {
+                    continue;
+                }
+                if (!$cm = $delegateinstance->get_cm()) {
+                    continue;
+                }
+                $this->delegatedbycm[$cm->id] = $section;
+            }
+        }
+        return $this->delegatedbycm;
+    }
     /**
      * Static cache for generated course_modinfo instances
+     *
      * @see course_modinfo::instance()
      * @see course_modinfo::clear_instance_cache()
+        }
         ksort($this->sectioninfobynum);
+    }
-    /**
-     * This method can not be used anymore.
-     *
-     * @see course_modinfo::build_course_cache()
-     * @deprecated since 2.6
-     */
-    public static function build_section_cache($courseid) {
-        throw new coding_exception('Function course_modinfo::build_section_cache() can not be used anymore.' .
-            ' Please use course_modinfo::build_course_cache() whenever applicable.');
-    }
     /**
      * Builds a list of information about sections on a course to be stored in
      * the course cache. (Does not include information that is already cached
      * in some other way.)
+     *
     public static function purge_course_cache(int $courseid): void {
         increment_revision_number('course', 'cacherev', 'id = :id', array('id' => $courseid));
         // Because this is a versioned cache, there is no need to actually delete the cache item,
         // only increase the required version number.
+    }
+    /**
+     * Can this module type be displayed on a course page or selected from the activity types when adding an activity to a course?
+     *
+     * @param string $modname The module type name
+     * @return bool
+     */
+    public static function is_mod_type_visible_on_course(string $modname): bool {
+        return plugin_supports('mod', $modname, FEATURE_CAN_DISPLAY, true);
+    }
+    /**
+     * Get content weights for all sections and modules in the course.
+     *
+     * The weights are calculated based on the order of sections and modules
+     * as they appear on the course page, including delegated sections.
+     *
+     * @return array Associative array with keys 'section{sectionid}' and 'cm{cmid}' and integer weights as values.
+     */
+    private function get_content_weights(): array {
+        if ($this->weights !== null) {
+            return $this->weights;
+        }
+        $result = [];
+        foreach ($this->sectioninfobynum as $section) {
+            // Delegated sections are always at the end of the course and they will
+            // be added only if they are part of any section sequence.
+            if ($section->is_delegated()) {
+                continue;
+            }
+            $sortedelements = $this->calculate_section_weights($section, count($result));
+            $result += $sortedelements;
+        }
+        $this->weights = $result;
+        return $result;
+    }
+    /**
+     * Calculate weights for a section and its modules, including delegated sections.
+     *
+     * @param section_info $section The section to calculate weights for.
+     * @param int $currentweight The starting weight to use for this section.
+     * @return section_info[] Associative array of section_info objects, indexed by the cmid of the delegating module.
+     */
+    private function calculate_section_weights(section_info $section, int $currentweight = 0): array {
+        $delegatedcms = $this->get_sections_delegated_by_cm();
+        $weights = [
+            'section' . $section->id => $currentweight++,
+        ];
+        foreach ($section->get_sequence_cm_infos() as $cm) {
+            $weights['cm' . $cm->id] = $currentweight++;
+            if (array_key_exists($cm->id, $delegatedcms)) {
+                $subweights = $this->calculate_section_weights($delegatedcms[$cm->id], $currentweight);
+                $weights += $subweights;
+                $currentweight += count($subweights);
+            }
+        }
+        return $weights;
+    }
+}
      * @var string
      */
     private $iconcomponent;
+    /**
+     * The instance record form the module table
+     * @var stdClass
+     */
+    private $instancerecord;
     /**
      * Name of module e.g. 'forum' (this is the same name as the module's main database
      * table) - from cached data in modinfo field
      * @var string
      */
+        }
         return $cmrecord;
+    }
+    /**
+     * Return the activity database table record.
+     *
+     * The instance record will be cached after the first call.
+     *
+     * @return stdClass
+     */
+    public function get_instance_record() {
+        global $DB;
+        if (!isset($this->instancerecord)) {
+            $this->instancerecord = $DB->get_record(
+                table: $this->modname,
+                conditions: ['id' => $this->instance],
+                strictness: MUST_EXIST,
+            );
+        }
+        return $this->instancerecord;
+    }
+    /**
+     * Returns the section delegated by this module, if any.
+     *
+     * @return ?section_info
+     */
+    public function get_delegated_section_info(): ?section_info {
+        $delegatedsections = $this->modinfo->get_sections_delegated_by_cm();
+        if (!array_key_exists($this->id, $delegatedsections)) {
+            return null;
+        }
+        return $delegatedsections[$this->id];
+    }
     // Set functions
     ////////////////
         $this->obtain_dynamic_data();
         return $this->uservisibleoncoursepage;
+    }
+    /**
+     * Use this method if you want to check if the plugin overrides any visibility checks to block rendering to the display.
+     *
+     * @return bool
+     */
+    public function is_of_type_that_can_display(): bool {
+        return course_modinfo::is_mod_type_visible_on_course($this->modname);
+    }
     /**
      * Whether this module is available but hidden from course page
+     *
      * "Stealth" modules are the ones that are not shown on course page but available by following url.
      * They are normally also displayed in grade reports and other reports.
         $this->obtain_dynamic_data();
         return $this->available;
+    }
-    /**
-     * This method can not be used anymore.
-     *
-     * @see \core_availability\info_module::filter_user_list()
-     * @deprecated Since Moodle 2.8
-     */
-    private function get_deprecated_group_members_only() {
-        throw new coding_exception('$cm->groupmembersonly can not be used anymore. ' .
-                'If used to restrict a list of enrolled users to only those who can ' .
-                'access the module, consider \core_availability\info_module::filter_user_list.');
-    }
     /**
      * Getter method for property $availableinfo, ensures that dynamic data is retrieved
+     *
      * @return string Available info (HTML)
      */
              $this->uservisible = false;
             // Ensure activity is completely hidden from the user.
             $this->availableinfo = '';
+        }
+        $capabilities = [
+            'moodle/course:manageactivities',
+            'moodle/course:activityvisibility',
+            'moodle/course:viewhiddenactivities',
         ];
-        $this->uservisibleoncoursepage = $this->uservisible &&
-            ($this->visibleoncoursepage ||
-                has_capability('moodle/course:manageactivities', $this->get_context(), $userid) ||
+        $this->uservisibleoncoursepage = $this->uservisible &&
-                has_capability('moodle/course:activityvisibility', $this->get_context(), $userid));
+            ($this->visibleoncoursepage || has_any_capability($capabilities, $this->get_context(), $userid));
         // Activity that is not available, not hidden from course page and has availability
         // info is actually visible on the course page (with availability info and without a link).
         if (!$this->uservisible && $this->visibleoncoursepage && $this->availableinfo) {
             $this->uservisibleoncoursepage = true;
+        }
+    }
-    /**
-     * This method has been deprecated and should not be used.
-     *
-     * @see $uservisible
-     * @deprecated Since Moodle 2.8
-     */
-    public function is_user_access_restricted_by_group() {
-        throw new coding_exception('cm_info::is_user_access_restricted_by_group() can not be used any more.' .
-            ' Use $cm->uservisible to decide whether the current user can access an activity.');
-    }
     /**
      * Checks whether mod/...:view capability restricts the current user's access.
+     *
      * @return bool True if the user access is restricted.
         // You are blocked if you don't have the capability.
         return !has_capability($capability, $this->get_context(), $userid);
+    }
-    /**
-     * Checks whether the module's conditional access settings mean that the
-     * user cannot see the activity at all
-     *
-     * @deprecated since 2.7 MDL-44070
-     */
-    public function is_user_access_restricted_by_conditional_access() {
-        throw new coding_exception('cm_info::is_user_access_restricted_by_conditional_access() ' .
-                'can not be used any more; this function is not needed (use $cm->uservisible ' .
-                'and $cm->availableinfo to decide whether it should be available ' .
-                'or appear)');
-    }
     /**
      * Calls a module function (if exists), passing in one parameter: this object.
      * @param string $type Name of function e.g. if this is 'grooblezorb' and the modname is
      *   'forum' then it will try to call 'mod_forum_grooblezorb' or 'forum_grooblezorb'
      * @return void
+        }
+    }
     // Get cm from get_fast_modinfo.
     $modinfo = get_fast_modinfo($course, $userid);
-    $instances = $modinfo->get_instances_of($modulename);
-    if (!array_key_exists($instanceid, $instances)) {
-        throw new moodle_exception('invalidmoduleid', 'error', '', $instanceid);
-    }
+    $instance = $modinfo->get_instance_of($modulename, $instanceid, MUST_EXIST);
-    return array($course, $instances[$instanceid]);
+    return [$course, $instance];
+}
     /**
      * @var sectiondelegate|null Section delegate instance if any.
      */
     private ?sectiondelegate $_delegateinstance = null;
+    /** @var cm_info[]|null Section cm_info activities, null when it is not loaded yet. */
+    private array|null $_sequencecminfos = null;
+    /**
+     * @var bool|null $_isorphan True if the section is orphan for some reason.
+     */
+    private $_isorphan = null;
     /**
      * Availability conditions for this section based on the completion of
      * course-modules (array from course-module id to required completion state
      * for that module) - from cached data in sectioncache field
             // Get availability information.
             $ci = new \core_availability\info_section($this);
             $this->_available = $ci->is_available($this->_availableinfo, true,
                     $userid, $this->modinfo);
+        }
+        if ($this->_available) {
+            $this->_available = $this->check_delegated_available();
+        }
         // Execute the hook from the course format that may override the available/availableinfo properties.
         $currentavailable = $this->_available;
         course_get_format($this->modinfo->get_course())->
             section_get_available_hook($this, $this->_available, $this->_availableinfo);
         if (!$currentavailable && $this->_available) {
+        }
         return $this->_available;
+    }
+    /**
+     * Check if the delegated component is available.
+     *
+     * @return bool
+     */
+    private function check_delegated_available(): bool {
+        /** @var sectiondelegatemodule $sectiondelegate */
+        $sectiondelegate = $this->get_component_instance();
+        if (!$sectiondelegate) {
+            return true;
+        }
+        if ($sectiondelegate instanceof sectiondelegatemodule) {
+            $parentcm = $sectiondelegate->get_cm();
+            if (!$parentcm->available) {
+                return false;
+            }
+            return $parentcm->get_section_info()->available;
+        }
+        return true;
+    }
     /**
      * Returns the availability text shown next to the section on course page.
+     *
      * @return string
      */
         $userid = $this->modinfo->get_user_id();
         if ($this->_uservisible !== null || $userid == -1) {
             // Has already been calculated or does not need calculation.
             return $this->_uservisible;
+        }
+        if (!$this->check_delegated_uservisible()) {
+            $this->_uservisible = false;
+            return $this->_uservisible;
+        }
         $this->_uservisible = true;
-        if (!$this->_visible || !$this->get_available()) {
+        if ($this->is_orphan() || !$this->_visible || !$this->get_available()) {
             $coursecontext = context_course::instance($this->get_course());
+            if (
+                ($this->_isorphan || !$this->_visible)
-            if (!$this->_visible && !has_capability('moodle/course:viewhiddensections', $coursecontext, $userid) ||
+                && !has_capability('moodle/course:viewhiddensections', $coursecontext, $userid)
+            ) {
+                $this->_uservisible = false;
+            }
+            if (
+                $this->_uservisible
-                    (!$this->get_available() &&
+                && !$this->get_available()
-                    !has_capability('moodle/course:ignoreavailabilityrestrictions', $coursecontext, $userid))) {
+                && !has_capability('moodle/course:ignoreavailabilityrestrictions', $coursecontext, $userid)
+            ) {
                 $this->_uservisible = false;
+            }
+        }
         return $this->_uservisible;
+    }
+    /**
+     * Check if the delegated component is user visible.
+     *
+     * @return bool
+     */
+    private function check_delegated_uservisible(): bool {
+        /** @var sectiondelegatemodule $sectiondelegate */
+        $sectiondelegate = $this->get_component_instance();
+        if (!$sectiondelegate) {
+            return true;
+        }
+        if ($sectiondelegate instanceof sectiondelegatemodule) {
+            $parentcm = $sectiondelegate->get_cm();
+            if (!$parentcm->uservisible) {
+                return false;
+            }
+            $result = $parentcm->get_section_info()->uservisible;
+            return $result;
+        }
+        return true;
+    }
     /**
      * Restores the course_sections.sequence value
+     *
      * @return string
      */
             return '';
+        }
+    }
+    /**
+     * Returns the course modules in this section.
+     *
+     * @return cm_info[]
+     */
+    public function get_sequence_cm_infos(): array {
+        if ($this->_sequencecminfos !== null) {
+            return $this->_sequencecminfos;
+        }
+        $sequence = $this->modinfo->sections[$this->_sectionnum] ?? [];
+        $cms = $this->modinfo->get_cms();
+        $result = [];
+        foreach ($sequence as $cmid) {
+            if (isset($cms[$cmid])) {
+                $result[] = $cms[$cmid];
+            }
+        }
+        $this->_sequencecminfos = $result;
+        return $result;
+    }
     /**
      * Returns course ID - from course_sections table
+     *
      * @return int
      */
     /**
      * Get the delegate component instance.
      */
     public function get_component_instance(): ?sectiondelegate {
-        if (empty($this->_component)) {
+        if (!$this->is_delegated()) {
             return null;
+        }
         if ($this->_delegateinstance !== null) {
             return $this->_delegateinstance;
     public function is_delegated(): bool {
         return !empty($this->_component);
+    }
+    /**
+     * Returns true if this section is orphan.
+     *
+     * @return bool
+     */
+    public function is_orphan(): bool {
+        if ($this->_isorphan !== null) {
+            return $this->_isorphan;
+        }
+        $courseformat = course_get_format($this->modinfo->get_course());
+        // There are some cases where a restored course using third-party formats can
+        // have orphaned sections due to a fixed section number.
+        if ($this->_sectionnum > $courseformat->get_last_section_number()) {
+            $this->_isorphan = true;
+            return $this->_isorphan;
+        }
+        // Some delegated sections can belong to a plugin that is disabled or not present.
+        if ($this->is_delegated() && !$this->get_component_instance()) {
+            $this->_isorphan = true;
+            return $this->_isorphan;
+        }
+        $this->_isorphan = false;
+        return $this->_isorphan;
+    }
     /**
      * Prepares section data for inclusion in sectioncache cache, removing items
      * that are set to defaults, and adding availability data if required.
+     *
      * Called by build_section_cache in course_modinfo only; do not use otherwise.

Proyectos de Subversion Moodle

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