Learning catalogue

 
        // Make sure the file pool directory exists.
        if (!is_dir($this->filedir)) {
            if (!mkdir($this->filedir, $this->dirpermissions, true)) {
                // Permission trouble.
                throw new file_exception('storedfilecannotcreatefiledirs');
            }
 
            // Place warning file in file pool root.
            if (!file_exists($this->filedir.'/warning.txt')) {
                file_put_contents($this->filedir.'/warning.txt',
                        'This directory contains the content of uploaded files and is controlled by Moodle code. ' .
                        'Do not manually move, change or rename any of the files and subdirectories here.');
                chmod($this->filedir . '/warning.txt', $this->filepermissions);
            }
        }
 
        // Make sure the trashdir directory exists too.
        if (!is_dir($this->trashdir)) {
            if (!mkdir($this->trashdir, $this->dirpermissions, true)) {
                // Permission trouble.
                throw new file_exception('storedfilecannotcreatefiledirs');
            }
        }
    }
 
    /**
     * Get the full path for the specified hash, including the path to the filedir.
     *
     * @param string $contenthash The content hash
     * @param bool $fetchifnotfound Whether to attempt to fetch from the remote path if not found.
     * @return string The full path to the content file
     */
    protected function get_local_path_from_hash($contenthash, $fetchifnotfound = false) {
        return $this->get_fulldir_from_hash($contenthash) . '/' .$contenthash;
    }
 
    /**
     * Get a remote filepath for the specified stored file.
     *

        $this->setup_file_system();
    }
 
    /**
     * Complete setup procedure for the file_system component.
     *
     * @return file_system
     */
    public function setup_file_system() {
        global $CFG;
        if ($this->filesystem === null) {
            require_once($CFG->libdir . '/filestorage/file_system.php');
            if (!empty($CFG->alternative_file_system_class)) {
                $class = $CFG->alternative_file_system_class;
            } else {
                // The default file_system is the filedir.
                require_once($CFG->libdir . '/filestorage/file_system_filedir.php');
                $class = file_system_filedir::class;
            }
            $this->filesystem = new $class();
        }
 
        return $this->filesystem;
    }
 
    /**
     * Return the file system instance.
     *
     * @return file_system
     */
    public function get_file_system() {
        return $this->filesystem;
    }
 
    /**
     * Calculates sha1 hash of unique full path name information.
     *
     * This hash is a unique file identifier - it is used to improve
     * performance and overcome db index size limits.
     *

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 * @since     Moodle 2.0
 */
class file_storage {
 
    /** @var string tempdir */
    private $tempdir;
 
    /** @var file_system filesystem */
    private $filesystem;
 
    /**
     * Constructor - do not use directly use {@link get_file_storage()} call instead.
     */
    public function __construct() {
        // The tempdir must always remain on disk, but shared between all ndoes in a cluster. Its content is not subject
        // to the file_system abstraction.
        $this->tempdir = make_temp_directory('filestorage');
 
        $this->setup_file_system();
    }
 
    /**
     * Complete setup procedure for the file_system component.
     *
     * @return file_system
     */
    public function setup_file_system() {
        global $CFG;
        if ($this->filesystem === null) {
            require_once($CFG->libdir . '/filestorage/file_system.php');
            if (!empty($CFG->alternative_file_system_class)) {
                $class = $CFG->alternative_file_system_class;
            } else {
                // The default file_system is the filedir.
                require_once($CFG->libdir . '/filestorage/file_system_filedir.php');
                $class = file_system_filedir::class;
            }
            $this->filesystem = new $class();
        }

 *
 * @return ?file_storage
 */
function get_file_storage($reset = false) {
    global $CFG;
 
    static $fs = null;
 
    if ($reset) {
        $fs = null;
        return;
    }
 
    if ($fs) {
        return $fs;
    }
 
    require_once("$CFG->libdir/filelib.php");
 
    $fs = new file_storage();
 
    return $fs;
}
 
/**
 * Returns local file storage instance
 *
 * @return file_browser
 */
function get_file_browser() {
    global $CFG;
 
    static $fb = null;
 
    if ($fb) {
        return $fb;
    }
 
    require_once("$CFG->libdir/filelib.php");
 

     * @return string|null
     */
    private static function course_image_url(
        \stdClass $course,
        \context_course $context,
        string $categorypath = ''
    ): ?string {
        // 1. Explicit per-course "Catalogue image" pick wins when set — but only
        // when its asset actually exists, so a stale slug (e.g. a default that
        // ships no image yet) does not shadow the real course image below.
        $override = course_image_library::override_for_course((int) $course->id);
        if ($override !== null) {
            $overrideurl = course_image_library::image_file_url($override);
            if ($overrideurl !== null) {
                return $overrideurl->out(false);
            }
        }
 
        // 2. The course's own image (course settings → Course image).
        $fs = get_file_storage();
        $files = $fs->get_area_files(
            $context->id,
            'course',
            'overviewfiles',
            0,
            'sortorder,filename',
            false
        );
        foreach ($files as $file) {
            if (strpos((string) $file->get_mimetype(), 'image/') !== 0) {
                continue;
            }
 
            // Course overviewfiles are stored with itemid 0 but MUST be served
            // with a null itemid (matching core's course_image cache builder) —
            // a literal /0/ segment in the pluginfile URL fails to resolve.
            return \moodle_url::make_pluginfile_url(
                $file->get_contextid(),
                $file->get_component(),
                $file->get_filearea(),

                $capacitystatus = offering_data::CAPACITY_ENROLLED;
                $capacitylabel = get_string('catalog_provider_course_inprogress', 'local_lernhive');
                $capacityfill = $percent;
            } else {
                $capacitystatus = offering_data::CAPACITY_ENROLLED;
                $capacitylabel = get_string('catalog_provider_course_enrolled', 'local_lernhive');
                $capacityfill = 0;
            }
        } else {
            $capacitystatus = offering_data::CAPACITY_OK;
            $capacitylabel = get_string('catalog_provider_course_available', 'local_lernhive');
            $capacityfill = 100;
        }
 
        return new offering_data(
            id: 'course-' . (int) $course->id,
            sourcecomponent: 'local_lernhive',
            title: $title,
            summary: self::card_summary($course, $offermetadata),
            imageurl: self::course_image_url($course, $context, $categorypath),
            metalines: [],
            badges: self::badges($course, $categorypath, $markings),
            ctaurl: $url,
            ctalabel: $requiresapproval
                ? get_string('catalog_provider_course_request', 'local_lernhive')
                : get_string('catalog_provider_course_cta', 'local_lernhive'),
            categorypath: $categorypath,
            startat: !empty($course->startdate) ? (int) $course->startdate : null,
            timecreated: !empty($course->timecreated) ? (int) $course->timecreated : null,
            availability: $requiresapproval
                ? offering_data::AVAILABILITY_ON_REQUEST
                : offering_data::AVAILABILITY_BOOKABLE,
            score: !empty($markings['featured']) ? 40 : 10,
            metaitems: $meta,
            capacitystatus: $capacitystatus,
            capacitylabel: $capacitylabel,
            capacityfill: $capacityfill,
            capacityisprogress: $isenrolled,
            showcapacitybar: $isenrolled,
            trainers: self::trainers_data($context),

            $window = $filter->limit;
        } else {
            $window = $total;
        }
 
        // Card data for the whole window in one go (task18).
        $windowcourses = array_slice($courses, 0, $window, true);
        $viewer = self::viewer($userid);
        self::preload_cards(array_map('intval', array_column($windowcourses, 'id')));
        $offerings = [];
        try {
            foreach ($courses as $course) {
                if (count($offerings) >= $window) {
                    break;
                }
                $context = \context_course::instance((int) $course->id, IGNORE_MISSING);
                if (!$context) {
                    continue;
                }
                $offerings[] = self::course_to_offering($course, $context, $userid, null, $viewer);
            }
        } finally {
            self::$cardbatch = null;
        }
 
        return ['offerings' => $offerings, 'total' => $total];
    }
 
    /**
     * Order light course rows like the catalogue's built-in sort modes,
     * including the registry's tie-break on the offering id.
     *
     * @param \stdClass[] $courses Rows from {@see matching_courses()}.
     * @param string $sort One of {@see WINDOW_SORTS}.
     * @return \stdClass[]
     */
    private static function sort_courses(array $courses, string $sort): array {
        $nullslast = static fn(\stdClass $c): int => (int) $c->startdate > 0 ? (int) $c->startdate : PHP_INT_MAX;
        $titles = [];
        if ($sort === 'title') {

     * myprofile tree stay untouched. The setting local_lernhive/profile_modern_style
     * turns it off again.
     *
     * @param before_html_attributes $hook HTML-attribute hook.
     */
    public static function add_profile_scope_attribute(before_html_attributes $hook): void {
        if (!get_config('local_lernhive', 'profile_modern_style')) {
            return;
        }
 
        $hook->add_attribute('data-lh-profile', 'person');
    }
 
    /**
     * Contribute ordinary Moodle courses to the central LernHive catalogue.
     *
     * @param collect_offerings $hook
     */
    public static function contribute_course_catalog_offerings(collect_offerings $hook): void {
        $window = course_catalog_provider::get_offering_window($hook->userid, $hook->filter);
        $hook->add_offerings($window['offerings']);
        $hook->set_total('local_lernhive', $window['total']);
    }
 
    /**
     * Contribute core catalogue facets.
     *
     * @param collect_facets $hook
     */
    public static function contribute_course_catalog_facets(collect_facets $hook): void {
        $hook->add_facets(course_catalog_provider::get_facets($hook->userid));
    }
 
    /**
     * Register core catalogue sort options.
     *
     * @param collect_sort_options $hook Sort-option collection hook.
     */
    public static function contribute_course_catalog_sort_options(collect_sort_options $hook): void {
        // Core owns the built-in modes. Feature plugins may register more modes.

        if (empty($callbacks)) {
            // Nothing is interested in this hook.
            return $event;
        }
 
        foreach ($callbacks as $callback) {
            // Note: PSR-14 states:
            // If passed a Stoppable Event, a Dispatcher
            // MUST call isPropagationStopped() on the Event before each Listener has been called.
            // If that method returns true it MUST return the Event to the Emitter immediately and
            // MUST NOT call any further Listeners. This implies that if an Event is passed to the
            // Dispatcher that always returns true from isPropagationStopped(), zero listeners will be called.
            // Ergo, we check for a stopped event before calling each listener, not afterwards.
            if ($event instanceof StoppableEventInterface) {
                if ($event->isPropagationStopped()) {
                    return $event;
                }
            }
 
            call_user_func($callback, $event);
        }
 
        // Developers need to be careful to not create infinite loops in hook callbacks.
        return $event;
    }
 
    /**
     * Initialise list of all callbacks for each hook.
     */
    private function init_standard_callbacks(): void {
        global $CFG;
 
        $this->allcallbacks = [];
        $this->alldeprecations = [];
 
        // @codeCoverageIgnoreStart
        $shouldcache = $this->should_cache();
        if ($shouldcache) {
            $cache = $this->get_cache();
 

        if (empty($callbacks)) {
            // Nothing is interested in this hook.
            return $event;
        }
 
        foreach ($callbacks as $callback) {
            // Note: PSR-14 states:
            // If passed a Stoppable Event, a Dispatcher
            // MUST call isPropagationStopped() on the Event before each Listener has been called.
            // If that method returns true it MUST return the Event to the Emitter immediately and
            // MUST NOT call any further Listeners. This implies that if an Event is passed to the
            // Dispatcher that always returns true from isPropagationStopped(), zero listeners will be called.
            // Ergo, we check for a stopped event before calling each listener, not afterwards.
            if ($event instanceof StoppableEventInterface) {
                if ($event->isPropagationStopped()) {
                    return $event;
                }
            }
 
            call_user_func($callback, $event);
        }
 
        // Developers need to be careful to not create infinite loops in hook callbacks.
        return $event;
    }
 
    /**
     * Initialise list of all callbacks for each hook.
     */
    private function init_standard_callbacks(): void {
        global $CFG;
 
        $this->allcallbacks = [];
        $this->alldeprecations = [];
 
        // @codeCoverageIgnoreStart
        $shouldcache = $this->should_cache();
        if ($shouldcache) {
            $cache = $this->get_cache();
 

            return self::collect_page($userid, $filter, $sortid, $lastpage, $perpage);
        }
        return [
            'offerings' => array_slice($result['offerings'], $page * $perpage, $perpage),
            'total' => $result['total'],
            'page' => $page,
        ];
    }
 
    /**
     * Dispatch the hook, filter, sort and count.
     *
     * @param int $userid Viewer id.
     * @param search_filter $filter Filter, possibly with a window.
     * @param string $sortid Sort mode id.
     * @return array{offerings:offering_data[],total:int}
     */
    private static function collect(int $userid, search_filter $filter, string $sortid): array {
        $hook = new collect_offerings($userid, $filter);
        di::get(hook_manager::class)->dispatch($hook);
 
        $offerings = $hook->get_offerings();
        $offerings = self::apply_visibility_filters($userid, $offerings, $filter);
 
        $option = self::sort_option($userid, $sortid);
        usort($offerings, static function (offering_data $a, offering_data $b) use ($option): int {
            $result = $option->compare($a, $b);
            return $result !== 0 ? $result : [$a->sourcecomponent, $a->id] <=> [$b->sourcecomponent, $b->id];
        });
 
        // Providers that reported a full count (they applied the visibility
        // rules themselves) count with it; every other provider with what
        // survived the filters above.
        $totals = $hook->get_totals();
        $total = array_sum($totals);
        foreach ($offerings as $offering) {
            if (!array_key_exists($offering->sourcecomponent, $totals)) {
                $total++;
            }
        }

     * Merging the sorted heads of every provider yields the same first
     * `($page + 1) * $perpage` offerings as sorting everything.
     *
     * @param int $userid Viewer id, 0 for the public catalogue.
     * @param search_filter $filter Resolved filter values.
     * @param string $sortid Sort mode id.
     * @param int $page Zero-based page.
     * @param int $perpage Offerings per page.
     * @return array{offerings:offering_data[],total:int,page:int} The page (clamped to the last one) and the total.
     */
    public static function collect_page(
        int $userid,
        search_filter $filter,
        string $sortid,
        int $page,
        int $perpage
    ): array {
        $perpage = max(1, $perpage);
        $page = max(0, $page);
        $result = self::collect($userid, $filter->with_window($sortid, ($page + 1) * $perpage), $sortid);
        $lastpage = max(0, (int) ceil($result['total'] / $perpage) - 1);
        if ($page > $lastpage) {
            // A stale deep link past the end shows the last page instead of nothing.
            return self::collect_page($userid, $filter, $sortid, $lastpage, $perpage);
        }
        return [
            'offerings' => array_slice($result['offerings'], $page * $perpage, $perpage),
            'total' => $result['total'],
            'page' => $page,
        ];
    }
 
    /**
     * Dispatch the hook, filter, sort and count.
     *
     * @param int $userid Viewer id.
     * @param search_filter $filter Filter, possibly with a window.
     * @param string $sortid Sort mode id.
     * @return array{offerings:offering_data[],total:int}
     */

            ? new \moodle_url($this->baseurl)
            : new \moodle_url('/local/lernhive/catalog.php');
        foreach ($params as $name => $value) {
            $url->param($name, $value);
        }
        return $url;
    }
 
    /**
     * Export the catalogue template context.
     *
     * @param \renderer_base $output Renderer instance.
     * @return array<string,mixed> Template context.
     */
    public function export_for_template(\renderer_base $output): array {
        $sortid = (string) ($this->rawparams['sort'] ?? 'relevance');
        // Real paging over the whole result (task36): providers build cards
        // only for the window, the counts come from their full match counts.
        // A host without paging shows the first page.
        $result = catalog_registry::collect_page($this->userid, $this->filter, $sortid, $this->page ?? 0, self::PER_PAGE);
        $offerings = $result['offerings'];
        $matchcount = $result['total'];
        $totalcount = catalog_registry::collect_page($this->userid, new search_filter(), $sortid, 0, 1)['total'];
        $pagingbar = '';
        if ($this->page !== null && $matchcount > self::PER_PAGE) {
            $pagingbar = $output->render(new \paging_bar(
                $matchcount,
                $result['page'],
                self::PER_PAGE,
                $this->url($this->rawparams)
            ));
        }
        $sortoptions = catalog_registry::collect_sort_options($this->userid);
        $selectedsort = catalog_registry::sort_option($this->userid, $sortid);
 
        // Preserve any non-search params (e.g. format=, category=) across the
        // search-submit so a click on the search button does not silently drop
        // an active tag-driven filter.
        $extras = [];
        foreach ($this->rawparams as $name => $value) {

 
// View switcher (cards | month) — shared with the full-view catalogue block,
// see `catalog_view`.
$togglebase = new moodle_url('/local/lernhive/catalog.php', $rawparams);
echo catalog_view::view_toggle($togglebase, $view);
 
if ($view === catalog_view::VIEW_MONTH) {
    $monthhtml = catalog_view::month_html(
        $OUTPUT,
        $PAGE,
        $togglebase,
        $filter,
        $rawparams,
        $calendartime,
        (int) ($rawparams['expand'] ?? 0)
    );
    $renderable = new catalog_page($userid, $filter, $rawparams, $monthhtml, null, $dateerror);
    echo $OUTPUT->render_from_template(
        'local_lernhive/catalog_page',
        $renderable->export_for_template($OUTPUT)
    );
} else {
    $renderable = new catalog_page($userid, $filter, $rawparams, null, null, $dateerror, $page);
    echo $OUTPUT->render_from_template(
        'local_lernhive/catalog_page',
        $renderable->export_for_template($OUTPUT)
    );
}
 
echo html_writer::end_div();
echo $OUTPUT->footer();