* @author     Frédéric Massart <fred@branchup.tech>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
 
/**
 * Create a definition from data.
 *
 * This defines what a definition looks like, and what keys are expected to be given as argument.
 *
 * @param string $shortcode The shortcode.
 * @param array $data The data.
 * @return object
 */
function filter_shortcodes_definition_from_data($shortcode, array $data) {
    global $CFG;
 
    if ($CFG->debugdeveloper) {
        validate_param($shortcode, PARAM_ALPHANUM);
 
        if (!isset($data['callback']) || !is_callable($data['callback'])) {
            throw new coding_exception("The callback for shortcode '{$shortcode}' is invalid.");
        }
 
        if (!isset($data['component'])) {
            throw new coding_exception("A shortcode must belong to a component.");
        }
 
        if (isset($data['description'])) {
            $stringman = get_string_manager();
            if (!$stringman->string_exists($data['description'], $data['component'])) {
                debugging("The definition string for shortcode '{$shortcode}' is invalid.", DEBUG_DEVELOPER);
                $data['description'] = null;
            }
        }
    }
 
    return (object) [
        'shortcode' => $shortcode,
        'callback' => $data['callback'],
        'component' => $data['component'],

                $component = $plugintype . '_' . $name;
                $info = $pluginman->get_plugin_info($component);
 
                // Skip unfound or disabled plugins. Note that the plugin manager can return null when
                // the status is unknown. In that case we keep the plugin (e.g. local plugins).
                if (!$info || $info->is_enabled() === false) {
                    continue;
                }
 
                // Is the file there? I wish we could use core_component::get_plugin_list_with_file().
                // But we cannot because only a few files are mapped, and ours isn't.
                $file = $rootdir . '/db/shortcodes.php';
                if (!file_exists($file)) {
                    continue;
                }
 
                $shortcodes = $saferead($file);
                foreach ($shortcodes as $shortcode => $data) {
                    $data['component'] = $component;
                    $definitions[] = filter_shortcodes_definition_from_data($shortcode, $data);
                }
            }
        }
 
        return $definitions;
    }
 
    /**
     * Load the things if need be.
     *
     * @return void
     */
    protected function init() {
        if ($this->registry === null) {
            $definitions = $this->cache->get('definitions');
            if ($definitions === false) {
                $definitions = $this->fetch_definitions();
                $this->cache->set('definitions', $definitions);
            }
            $this->registry = new static_registry($definitions);

                foreach ($shortcodes as $shortcode => $data) {
                    $data['component'] = $component;
                    $definitions[] = filter_shortcodes_definition_from_data($shortcode, $data);
                }
            }
        }
 
        return $definitions;
    }
 
    /**
     * Load the things if need be.
     *
     * @return void
     */
    protected function init() {
        if ($this->registry === null) {
            $definitions = $this->cache->get('definitions');
            if ($definitions === false) {
                $definitions = $this->fetch_definitions();
                $this->cache->set('definitions', $definitions);
            }
            $this->registry = new static_registry($definitions);
        }
    }
}
 

    }
 
    /**
     * Get the definitions.
     *
     * @return \Iterator
     */
    public function get_definitions() {
        $this->init();
        return $this->registry->get_definitions();
    }
 
    /**
     * Get a handler.
     *
     * @param string $shortcode The shortcode.
     * @return object|null
     */
    public function get_handler($shortcode) {
        $this->init();
        return $this->registry->get_handler($shortcode);
    }
 
    /**
     * Fetch all the definitions.
     *
     * @return array
     */
    protected function fetch_definitions() {
        $saferead = function ($file) {
            $shortcodes = [];
            include($file);
            return $shortcodes;
        };
 
        $pluginman = \core_plugin_manager::instance();
        $stringman = get_string_manager();
        $definitions = [];
 
        $types = core_component::get_plugin_types();

 
    /**
     * Constructor
     *
     * @param registry $registry The registry.
     */
    public function __construct(registry $registry) {
        $this->registry = $registry;
    }
 
    /**
     * Internal processing.
     *
     * @param string $text The text.
     * @param Closure $next The function to pipe the resulting content through, if needed.
     * @return string
     */
    protected function internal_process($text, $next) {
        return filter_shortcodes_process_text($text, function ($shortcode) use ($next) {
            $handler = $this->registry->get_handler($shortcode);
            if (!$handler) {
                return;
            }
            $processor = $handler->processor;
            return (object) [
                'hascontent' => $handler->wraps,
                'contentprocessor' => function ($args, $content) use ($processor, $shortcode, $next) {
                    // We decorate the handler method to pass through the other needed arguments.
                    return $processor($shortcode, $args, $content, $this->env, $next);
                },
            ];
        });
    }
 
    /**
     * The filtering occurs here.
     *
     * @param string $text The content to process.
     * @return string The resulting text.
     */

            return $text;
        }
 
        $start = $firstfind;
        $end = $end === null ? core_text::strlen($text) : $end;
        $pos = $firstfind + 1;
 
        // Find out what the tag is.
        $tag = '';
        do {
            $char = core_text::substr($text, $pos, 1);
            if (!preg_match($charregex, $char)) {
                break;
            }
            $tag .= $char;
            $pos++;
        } while ($pos < $end);
 
        // We have a tag and can we handle it?
        if ($tag && is_object($info = $informant($tag))) {
            if ($lastcloseself < $pos) {
                // The tag does not have an end.
                continue;
            }
 
            $tagclosed = false;
            $attrs = '';
            $inquote = false;
 
            do {
                $char = core_text::substr($text, $pos, 1);
 
                // Detect when we are in quotes, in order to avoid closing the tag too early.
                if ($char == '"') {
                    if ($inquote) {
                        $inquote = core_text::substr($text, $pos - 1, 1) !== '\\' ? false : true;
                    } else {
                        $inquote = true;
                    }
                }

    protected $registry;
 
    /**
     * Constructor
     *
     * @param registry $registry The registry.
     */
    public function __construct(registry $registry) {
        $this->registry = $registry;
    }
 
    /**
     * Internal processing.
     *
     * @param string $text The text.
     * @param Closure $next The function to pipe the resulting content through, if needed.
     * @return string
     */
    protected function internal_process($text, $next) {
        return filter_shortcodes_process_text($text, function ($shortcode) use ($next) {
            $handler = $this->registry->get_handler($shortcode);
            if (!$handler) {
                return;
            }
            $processor = $handler->processor;
            return (object) [
                'hascontent' => $handler->wraps,
                'contentprocessor' => function ($args, $content) use ($processor, $shortcode, $next) {
                    // We decorate the handler method to pass through the other needed arguments.
                    return $processor($shortcode, $args, $content, $this->env, $next);
                },
            ];
        });
    }
 
    /**
     * The filtering occurs here.
     *
     * @param string $text The content to process.
     * @return string The resulting text.

                    // We decorate the handler method to pass through the other needed arguments.
                    return $processor($shortcode, $args, $content, $this->env, $next);
                },
            ];
        });
    }
 
    /**
     * The filtering occurs here.
     *
     * @param string $text The content to process.
     * @return string The resulting text.
     */
    public function process($text) {
        if ($this->env === null) {
            throw new \coding_exception('The environment must be set between process calls.');
        }
 
        $env = $this->env;
        $result = $this->internal_process($text, function ($text) use ($env) {
            $result = $this->process($text);
            $this->set_env($env);
            return $result;
        });
 
        $this->env = null;
        return $result;
    }
 
    /**
     * Set the environment.
     *
     * @param stdClass $env The environment, must conform to filter_shortcodes_make_env.
     */
    public function set_env(stdClass $env) {
        $this->env = $env;
    }
}
 

 * @copyright  2024 Frédéric Massart
 * @author     Frédéric Massart <fred@branchup.tech>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class text_filter extends core_text_filter {
    /** @var processor The processor. */
    private $processor;
 
    /**
     * The filtering occurs here.
     *
     * @param string $text HTML content.
     * @param array $options Options passed to the filter.
     * @return string The new content.
     */
    public function filter($text, array $options = []) {
        $env = filter_shortcodes_make_env($this->context, $options);
        $processor = $this->get_processor();
        $processor->set_env($env);
        return $processor->process($text);
    }
 
    /**
     * Get the processor.
     *
     * @return standard_processor
     */
    private function get_processor() {
        if ($this->processor === null) {
            $this->processor = new standard_processor(new plugin_registry());
        }
        return $this->processor;
    }
}
 

     * @param array $options
     * @return string
     */
    public function filter_stage_pre_clean(string $text, array $options): string {
        // NOTE: override if necessary.
        return $text;
    }
 
    /**
     * Filter HTML text at the very end after text is sanitised.
     *
     * NOTE: this is called even if $options['noclean'] is true and text is not cleaned.
     *
     * @param string $text
     * @param array $options
     * @return string
     */
    public function filter_stage_post_clean(string $text, array $options): string {
        // NOTE: override if necessary.
        return $this->filter($text, $options);
    }
 
    /**
     * Filter simple text coming from format_string().
     *
     * Note that unless $CFG->formatstringstriptags is disabled
     * HTML tags are not expected in returned value.
     *
     * @param string $text
     * @param array $options
     * @return string
     */
    public function filter_stage_string(string $text, array $options): string {
        // NOTE: override if necessary.
        return $this->filter($text, $options);
    }
}
 
// Alias this class to the old name.
// This file will be autoloaded by the legacyclasses autoload system.

        array $options = [],
        ?array $skipfilters = null
    ) {
        if (!isset($options['stage'])) {
            $filtermethod = 'filter';
        } else if (in_array($options['stage'], ['pre_format', 'pre_clean', 'post_clean', 'string'], true)) {
            $filtermethod = 'filter_stage_' . $options['stage'];
        } else {
            $filtermethod = 'filter';
            debugging('Invalid filter stage specified in options: ' . $options['stage'], DEBUG_DEVELOPER);
        }
        if ($text === null || $text === '') {
            // Nothing to filter.
            return '';
        }
        foreach ($filterchain as $filtername => $filter) {
            if ($skipfilters !== null && in_array($filtername, $skipfilters)) {
                continue;
            }
            $text = $filter->$filtermethod($text, $options);
        }
        return $text;
    }
 
    /**
     * Get all the filters that apply to a given context for calls to format_text.
     *
     * @param context $context
     * @return moodle_text_filter[] A text filter
     */
    protected function get_text_filters($context) {
        if (!isset($this->textfilters[$context->id])) {
            $this->load_filters($context);
        }
        return $this->textfilters[$context->id];
    }
 
    /**
     * Get all the filters that apply to a given context for calls to format_string.
     *

        }
        return $this->stringfilters[$context->id];
    }
 
    /**
     * Filter some text
     *
     * @param string $text The text to filter
     * @param context $context the context.
     * @param array $options options passed to the filters
     * @param null|array $skipfilters of filter names. Any filters that should not be applied to this text.
     * @return string resulting text
     */
    public function filter_text(
        $text,
        $context,
        array $options = [],
        ?array $skipfilters = null
    ) {
        $text = $this->apply_filter_chain($text, $this->get_text_filters($context), $options, $skipfilters);
        if (!isset($options['stage']) || $options['stage'] === 'post_clean') {
            // Remove <nolink> tags for XHTML compatibility after the last filtering stage.
            $text = str_replace(['<nolink>', '</nolink>'], '', $text);
        }
        return $text;
    }
 
    /**
     * Filter a piece of string
     *
     * @param string $string The text to filter
     * @param context $context the context.
     * @return string resulting string
     */
    public function filter_string($string, $context) {
        return $this->apply_filter_chain($string, $this->get_string_filters($context), ['stage' => 'string']);
    }
 
    /**
     * Setup page with filters requirements and other prepare stuff.

                        'allowid' => $allowid,
                    ]);
                }
                $filteroptions['stage'] = 'post_clean';
                $text = $filtermanager->filter_text($text, $context, $filteroptions);
                break;
 
            case FORMAT_MOODLE:
                $filteroptions['stage'] = 'pre_format';
                $text = $filtermanager->filter_text($text, $context, $filteroptions);
                $text = text_to_html($text, null, $para, $newlines);
                $filteroptions['stage'] = 'pre_clean';
                $text = $filtermanager->filter_text($text, $context, $filteroptions);
                if ($clean) {
                    $text = clean_text($text, FORMAT_HTML, [
                        'allowid' => $allowid,
                    ]);
                }
                $filteroptions['stage'] = 'post_clean';
                $text = $filtermanager->filter_text($text, $context, $filteroptions);
                break;
            default:  // FORMAT_MOODLE or anything else.
                throw new \coding_exception("Unknown format passed to format_text: {$format}");
        }
 
        if ($filter) {
            // At this point there should not be any draftfile links any more,
            // this happens when developers forget to post process the text.
            // The only potential problem is that somebody might try to format
            // the text before storing into database which would be itself big bug.
            $text = str_replace("\"$CFG->wwwroot/draftfile.php", "\"$CFG->wwwroot/brokenfile.php#", $text);
 
            if ($CFG->debugdeveloper) {
                if (strpos($text, '@@PLUGINFILE@@/') !== false) {
                    debugging(
                        'Before calling format_text(), the content must be processed with file_rewrite_pluginfile_urls()',
                        DEBUG_DEVELOPER
                    );
                }
            }

                unset($options[$option]);
            }
        }
 
        foreach ($options as $option => $value) {
            $params[$option] = $value;
        }
 
        // The noclean option has been renamed to clean.
        if (array_key_exists('noclean', $params)) {
            $params['clean'] = !$params['noclean'];
            unset($params['noclean']);
        }
    }
 
    if ($format !== null) {
        $params['format'] = $format;
    }
 
    return \core\di::get(\core\formatting::class)->format_text(...$params);
}
 
/**
 * Resets some data related to filters, called during upgrade or when general filter settings change.
 *
 * @param bool $phpunitreset true means called from our PHPUnit integration test reset
 * @return void
 */
function reset_text_filters_cache($phpunitreset = false) {
    global $CFG, $DB;
 
    if ($phpunitreset) {
        // HTMLPurifier does not change, DB is already reset to defaults,
        // nothing to do here, the dataroot was cleared too.
        return;
    }
 
    // The purge_all_caches() deals with cachedir and localcachedir purging,
    // the individual filter caches are invalidated as necessary elsewhere.
 

    /**
     * Returns given course's summary with proper embedded files urls and formatted
     *
     * @param core_course_list_element $course
     * @param array|stdClass $options additional formatting options
     * @return string
     */
    public function get_course_formatted_summary($course, $options = array()) {
        global $CFG;
        require_once($CFG->libdir. '/filelib.php');
        if (!$course->has_summary()) {
            return '';
        }
        $options = (array)$options;
        $context = context_course::instance($course->id);
        if (!isset($options['context'])) {
            $options['context'] = $context;
        }
        $summary = file_rewrite_pluginfile_urls($course->summary, 'pluginfile.php', $context->id, 'course', 'summary', null);
        $summary = format_text($summary, $course->summaryformat, $options);
        if (!empty($this->searchcriteria['search'])) {
            $summary = highlight($this->searchcriteria['search'], $summary);
        }
        return $summary;
    }
 
    /**
     * Returns course name as it is configured to appear in courses lists formatted to course context
     *
     * @param core_course_list_element $course
     * @param array|stdClass $options additional formatting options
     * @return string
     */
    public function get_course_formatted_name($course, $options = array()) {
        $options = (array)$options;
        if (!isset($options['context'])) {
            $options['context'] = context_course::instance($course->id);
        }
        $name = format_string(get_course_display_name_for_list($course), true, $options);
        if (!empty($this->searchcriteria['search'])) {

     * @throws \moodle_exception
     */
    public function get_category(): string {
        $cat = core_course_category::get($this->course->category, IGNORE_MISSING);
 
        if (!$cat) {
            return '';
        }
 
        return $cat->get_formatted_name();
    }
 
    /**
     * Returns course summary.
     *
     * @param coursecat_helper $chelper
     */
    public function get_summary(coursecat_helper $chelper): string {
        if ($this->course->has_summary()) {
            return $chelper->get_course_formatted_summary(
                $this->course,
                ['overflowdiv' => true, 'noclean' => true, 'para' => false]
            );
        }
 
        return false;
    }
 
    /**
     * Returns course custom fields.
     *
     * @return string
     */
    public function get_custom_fields(): string {
        if ($this->course->has_custom_fields()) {
            $handler = \core_course\customfield\course_handler::create();
 
            return $handler->display_custom_fields_data($this->course->get_custom_fields());
        }
 

        if ($courseprogressbar == 1 && $hasprogress == true) {
            $cccfooter = false;
        }
 
        $forcedlanguage = ($theme->settings->courselangbadge == 1) ? strval($course->lang) : null;
        $showcustomfields = ($theme->settings->showcustomfields == 1) ? true : false;
 
        $stringaccess = format_text(theme_space_get_setting('stringaccess'), FORMAT_HTML, ['noclean' => true]);
 
        $courseimage = $courseutil->get_summary_image(false);
        if (empty($courseimage)) {
            $courseimage = $this->get_theme_core_renderer()->get_generated_image_for_id($course->id);
        }
 
        $data = [
            'id' => $course->id,
            'fullname' => $chelper->get_course_formatted_name($course),
            'visible' => $course->visible,
            'image' => $courseimage,
            'summary' => $courseutil->get_summary($chelper),
            'category' => $courseutil->get_category(),
            'customfields' => $courseutil->get_custom_fields(),
            'showcustomfields' => $showcustomfields,
            'hasprogress' => $hasprogress,
            'progress' => (int) $courseprogress,
            'hasenrolmenticons' => $courseenrolmenticons != false,
            'enrolmenticons' => $courseenrolmenticons,
            'hascontacts' => !empty($coursecontacts),
            'contacts' => $coursecontacts,
            'stringaccess' => $stringaccess,
            'cccteachers' => $cccteachers,
            'cccfooter' => $cccfooter,
            'cccsummary' => $cccsummary,
            'coursecarddesclimit' => $coursecarddesclimit,
            'forcedlanguage' => $forcedlanguage,
        ];
 
        if ($theme->settings->courselistview == 1) {
            return $this->render_from_template('theme_space/custom_courselist', $data);
        } else {

     * @param coursecat_helper $chelper various display options
     * @param core_course_list_element|stdClass $course
     * @param string $additionalclasses additional classes to add to the main <div> tag (usually
     *    depend on the course position in list - first/last/even/odd)
     * @return string
     */
    protected function coursecat_coursebox(coursecat_helper $chelper, $course, $additionalclasses = '') {
        if (!isset($this->strings->summary)) {
            $this->strings->summary = get_string('summary');
        }
 
        if ($chelper->get_show_courses() <= self::COURSECAT_SHOW_COURSES_COUNT) {
            return '';
        }
 
        if ($course instanceof stdClass) {
            $course = new core_course_list_element($course);
        }
 
        return $this->coursecat_coursebox_content($chelper, $course);
    }
 
    /**
     * Returns HTML to display a tree of subcategories and courses in the given category
     *
     * @param coursecat_helper $chelper various display options
     * @param core_course_category $coursecat top category (this category's name and description will NOT be added to the tree)
     * @return string
     */
    protected function coursecat_tree(coursecat_helper $chelper, $coursecat) {
        // Reset the category expanded flag for this course category tree first.
        $this->categoryexpandedonload = false;
        $categorycontent = $this->coursecat_category_content($chelper, $coursecat, 1);
        if (empty($categorycontent)) {
            return '';
        }
 
        // Start content generation.
        $content = '';
        $attributes = $chelper->get_and_erase_attributes('course_category_tree clearfix');

        }
 
        // Display list of courses.
        $attributes = $chelper->get_and_erase_attributes('courses');
        $content = html_writer::start_tag('div', $attributes);
 
        if (!empty($pagingbar)) {
            $content .= $pagingbar;
        }
 
        $coursecount = 1;
 
        if ($theme->settings->courselistview == 1) {
            $content .= html_writer::start_tag('div', ['class' => 'rui-course--list mt-2']);
        } else {
            $content .= html_writer::start_tag('div', ['class' => 'rui-course-card-deck mt-2', 'role' => 'list']);
        }
 
        foreach ($courses as $course) {
            $content .= $this->coursecat_coursebox($chelper, $course);
 
            $coursecount++;
        }
 
        $content .= html_writer::end_tag('div');
 
        if (!empty($pagingbar)) {
            $content .= $pagingbar;
        }
 
        if (!empty($morelink)) {
            $content .= $morelink;
        }
 
        $content .= html_writer::end_tag('div'); // End courses.
 
        return $content;
    }
 
    /**

     */
    public function frontpage_available_courses() {
        global $CFG;
 
        $chelper = new coursecat_helper();
        $chelper->set_show_courses(self::COURSECAT_SHOW_COURSES_EXPANDED)->
                set_courses_display_options(array(
                    'recursive' => true,
                    'limit' => $CFG->frontpagecourselimit,
                    'viewmoreurl' => new moodle_url('/course/index.php'),
                    'viewmoretext' => new lang_string('fulllistofcourses')));
 
        $chelper->set_attributes(array('class' => 'frontpage-course-list-all'));
        $courses = core_course_category::top()->get_courses($chelper->get_courses_display_options());
        $totalcount = core_course_category::top()->get_courses_count($chelper->get_courses_display_options());
        if (!$totalcount && !$this->page->user_is_editing() && has_capability('moodle/course:create', context_system::instance())) {
            // Print link to create a new course, for the 1st available category.
            return $this->add_new_course_button();
        }
        return $this->coursecat_courses($chelper, $courses, $totalcount);
    }
 
    /**
     * Returns HTML to the "add new course" button for the page
     *
     * @return string
     */
    public function add_new_course_button() {
        global $CFG;
        // Print link to create a new course, for the 1st available category.
        $output = $this->container_start('buttons');
        $url = new moodle_url('/course/edit.php', array('category' => $CFG->defaultrequestcategory, 'returnto' => 'topcat'));
        $output .= $this->single_button($url, get_string('addnewcourse'), 'get');
        $output .= $this->container_end('buttons');
        return $output;
    }
 
    /**
     * Returns HTML to print tree with course categories and courses for the frontpage
     *

                        require_once($CFG->dirroot .'/mod/forum/lib.php');
                        if (($newsforum = forum_get_course_forum($SITE->id, 'news')) &&
                                ($forumcontents = $this->frontpage_news($newsforum))) {
                            $newsforumcm = get_fast_modinfo($SITE)->instances['forum'][$newsforum->id];
                            $output .= $this->frontpage_part('skipsitenews', 'site-news-forum',
                                $newsforumcm->get_formatted_name(), $forumcontents);
                        }
                    }
                    break;
 
                case FRONTPAGEENROLLEDCOURSELIST:
                    $mycourseshtml = $this->frontpage_my_courses();
                    if (!empty($mycourseshtml)) {
                        $output .= $this->frontpage_part('skipmycourses', 'frontpage-course-list',
                            get_string('mycourses'), $mycourseshtml);
                    }
                    break;
 
                case FRONTPAGEALLCOURSELIST:
                    $availablecourseshtml = $this->frontpage_available_courses();
                    $output .= $this->frontpage_part('skipavailablecourses', 'frontpage-available-course-list',
                        get_string('availablecourses'), $availablecourseshtml);
                    break;
 
                case FRONTPAGECATEGORYNAMES:
                    $output .= $this->frontpage_part('skipcategories', 'frontpage-category-names',
                        get_string('categories'), $this->frontpage_categories_list());
                    break;
 
                case FRONTPAGECATEGORYCOMBO:
                    $output .= $this->frontpage_part('skipcourses', 'frontpage-category-combo',
                        get_string('courses'), $this->frontpage_combo_list());
                    break;
 
                case FRONTPAGECOURSESEARCH:
                    $output .= $this->box($this->course_search_form(''), 'd-flex justify-content-center');
                    break;
 
            }
            $output .= '<br />';

$siteformatoptions = course_get_format($SITE)->get_format_options();
$modinfo = get_fast_modinfo($SITE);
$modnamesused = $modinfo->get_used_module_names();
 
// Print Section or custom info.
if (!empty($CFG->customfrontpageinclude)) {
    // Pre-fill some variables that custom front page might use.
    $modnames = get_module_types_names();
    $modnamesplural = get_module_types_names(true);
    $mods = $modinfo->get_cms();
 
    include($CFG->customfrontpageinclude);
 
} else if ($siteformatoptions['numsections'] > 0) {
    echo $courserenderer->frontpage_section1();
}
// Include course AJAX.
include_course_ajax($SITE, $modnamesused);
 
echo $courserenderer->frontpage();
 
if ($editing && has_capability('moodle/course:create', context_system::instance())) {
    echo $courserenderer->add_new_course_button();
}
echo $OUTPUT->footer();