Proyectos de Subversion Moodle

<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * Tiny text editor integration - Language Producer.
 *
 * @package    editor_tiny
 * @copyright  2021 Andrew Lyons <andrew@nicols.co.uk>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

namespace editor_tiny;

// Disable moodle specific debug messages and any errors in output,
// comment out when debugging or better look into error log!
define('NO_DEBUG_DISPLAY', true);

// We need just the values from config.php and minlib.php.
define('ABORT_AFTER_CONFIG', true);

// This stops immediately at the beginning of lib/setup.php.
require('../../../config.php');

/**
 * An anonymous class to handle loading and serving lang files for TinyMCE.
 *
 * @copyright  2021 Andrew Lyons <andrew@nicols.co.uk>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class lang {
    /** @var string The language code to load */
    protected $lang;

    /** @var int The revision requested */
    protected $rev;

    /** @var bool Whether Moodle is fully loaded or not */
    protected $fullyloaded = false;

    /** @var string The complete path to the candidate file */
    protected $candidatefile;

    /**
     * Constructor to load and serve the langfile.
     */
    public function __construct() {
        $this->parse_file_information_from_url();
        $this->serve_file();
    }

    /**
     * Parse the file information from the URL.
     */
    protected function parse_file_information_from_url(): void {
        global $CFG;

        // The URL format is /[revision]/[lang].
        // The revision is an integer with negative values meaning the file is not cached.
        // The lang is a simple word with no directory separators or special characters.
        if ($slashargument = min_get_slash_argument()) {
            $slashargument = ltrim($slashargument, '/');
            if (substr_count($slashargument, '/') < 1) {
                css_send_css_not_found();
            }

            [$rev, $lang] = explode('/', $slashargument, 2);
            $rev  = min_clean_param($rev, 'INT');
            $lang = min_clean_param($lang, 'SAFEDIR');
        } else {
            $rev  = min_optional_param('rev', 0, 'INT');
            $lang = min_optional_param('lang', 'standard', 'SAFEDIR');
        }

        // Retrieve the correct language by converting to Moodle's language code format.
        $this->lang = str_replace('-', '_', $lang);
        $this->rev = $rev;
        $this->candidatefile = "{$CFG->localcachedir}/editor_tiny/{$this->rev}/lang/{$this->lang}/lang.json";
    }

    /**
     * Serve the language pack content.
     */
    protected function serve_file(): void {
        // Attempt to send the cached langpack.
        // We only cache the file if the rev is valid.
        if (min_is_revision_valid_and_current($this->rev)) {
            if ($this->is_candidate_file_available()) {
                // The send_cached_file_if_available function will exit if successful.
                // In theory the file could become unavailable after checking that the file exists.
                // Whilst this is unlikely, fall back to caching the content below.
                $this->send_cached_pack();
            }

            // The file isn't cached yet.
            // Load the content. store it in the cache, and serve it.
            $strings = $this->load_language_pack();
            $this->store_lang_file($strings);
            $this->send_cached();
        } else {
            // If the revision is less than 0, then do not cache anything.
            $strings = $this->load_language_pack();
            $this->send_uncached($strings);
        }
    }

    /**
     * Load the full Moodle Framework.
     */
    protected function load_full_moodle(): void {
        global $CFG, $DB, $SESSION, $OUTPUT, $PAGE;

        if ($this->is_full_moodle_loaded()) {
            return;
        }

        // Ok, now we need to start normal moodle script, we need to load all libs and $DB.
        define('ABORT_AFTER_CONFIG_CANCEL', true);

        // Session not used here.
        define('NO_MOODLE_COOKIES', true);

        // Ignore upgrade check.
        define('NO_UPGRADE_CHECK', true);

        require("{$CFG->dirroot}/lib/setup.php");
        $this->fullyloaded = true;
    }

    /**
     * Check whether Moodle is fully loaded.
     *
     * @return bool
     */
    public function is_full_moodle_loaded(): bool {
        return $this->fullyloaded;
    }

    /**
     * Load the language pack strings.
     *
     * @return string[]
     */
    protected function load_language_pack(): array {
        // We need to load the full moodle API to use the string manager.
        $this->load_full_moodle();

        // We maintain a list of string identifier to original TinyMCE string.
        // TinyMCE uses English language strings to perform translations.
        $stringlist = file_get_contents(__DIR__ . "/tinystrings.json");
        if (empty($stringlist)) {
            $this->send_not_found("Failed to load strings from tinystrings.json");
        }

        $stringlist = json_decode($stringlist, true);
        if (empty($stringlist)) {
            $this->send_not_found("Failed to load strings from tinystrings.json");
        }

        // Load all strings for the TinyMCE Editor which have a prefix of `tiny:` from the Moodle String Manager.
        $stringmanager = get_string_manager();
        $translatedvalues = array_filter(
            $stringmanager->load_component_strings('editor_tiny', $this->lang),
            function(string $value, string $key): bool {
                return strpos($key, 'tiny:') === 0;
            },
            ARRAY_FILTER_USE_BOTH
        );

        // We will associate the _original_ TinyMCE string to its translation, but only where it is different.
        // Where the original TinyMCE string matches the Moodle translation of it, we do not supply the string.
        $strings = [];
        foreach ($stringlist as $key => $value) {
            if (array_key_exists($key, $translatedvalues)) {
                if ($translatedvalues[$key] !== $value) {
                    $strings[$value] = $translatedvalues[$key];
                }
            }
        }

        // TinyMCE uses a secret string only present in some languages to set a language direction.
        // Rather than applying to only some languages, we just apply to all from our own langconfig.
        // Note: Do not rely on right_to_left() as the current language is unset.
        $strings['_dir'] = $stringmanager->get_string('thisdirection', 'langconfig', null, $this->lang);

        return $strings;
    }

    /**
     * Send a cached language pack.
     */
    protected function send_cached_pack(): void {
        global $CFG;

        if (file_exists($this->candidatefile)) {
            if (!empty($_SERVER['HTTP_IF_NONE_MATCH']) || !empty($_SERVER['HTTP_IF_MODIFIED_SINCE'])) {
                // We do not actually need to verify the etag value because our files
                // never change in cache because we increment the rev counter.
                $this->send_unmodified_headers(filemtime($this->candidatefile));
            }
            $this->send_cached($this->candidatefile);
        }
    }

    /**
     * Store a langauge cache file containing all of the processed strings.
     *
     * @param string[] $strings The strings to store
     */
    protected function store_lang_file(array $strings): void {
        global $CFG;

        clearstatcache();
        if (!file_exists(dirname($this->candidatefile))) {
            @mkdir(dirname($this->candidatefile), $CFG->directorypermissions, true);
        }

        // Prevent serving of incomplete file from concurrent request,
        // the rename() should be more atomic than fwrite().
        ignore_user_abort(true);

        // First up write out the single file for all those using decent browsers.
        $content = json_encode($strings, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES);

        $filename = $this->candidatefile;
        if ($fp = fopen($filename . '.tmp', 'xb')) {
            fwrite($fp, $content);
            fclose($fp);
            rename($filename . '.tmp', $filename);
            @chmod($filename, $CFG->filepermissions);
            @unlink($filename . '.tmp'); // Just in case anything fails.
        }

        ignore_user_abort(false);
        if (connection_aborted()) {
            die;
        }
    }

    /**
     * Check whether the candidate file exists.
     *
     * @return bool
     */
    protected function is_candidate_file_available(): bool {
        return file_exists($this->candidatefile);
    }

    /**
     * Get the eTag for the candidate file.
     *
     * This is a unique hash based on the file arguments.
     * It does not need to consider the file content because we use a cache busting URL.
     *
     * @return string The eTag content
     */
    protected function get_etag(): string {
        $etag = [
            $this->lang,
            $this->rev,
        ];

        return sha1(implode('/', $etag));
    }

    /**
     * Send the candidate file, with aggressive cachign headers.
     *
     * This includdes eTags, a last-modified, and expiry approximately 90 days in the future.
     */
    protected function send_cached(): void {
        $path = $this->candidatefile;

        // 90 days only - based on Moodle point release cadence being every 3 months.
        $lifetime = 60 * 60 * 24 * 90;

        header('Etag: "' . $this->get_etag() . '"');
        header('Content-Disposition: inline; filename="lang.php"');
        header('Last-Modified: ' . gmdate('D, d M Y H:i:s', filemtime($path)) . ' GMT');
        header('Expires: ' . gmdate('D, d M Y H:i:s', time() + $lifetime) . ' GMT');
        header('Pragma: ');
        header('Cache-Control: public, max-age=' . $lifetime . ', immutable');
        header('Accept-Ranges: none');
        header('Content-Type: application/json; charset=utf-8');
        if (!min_enable_zlib_compression()) {
            header('Content-Length: ' . filesize($path));
        }

        readfile($path);
        die;
    }

    /**
     * Sends the content directly without caching it.
     *
     * @param string[] $strings
     */
    protected function send_uncached(array $strings): void {
        header('Content-Disposition: inline; filename="styles_debug.php"');
        header('Last-Modified: ' . gmdate('D, d M Y H:i:s', time()) . ' GMT');
        header('Expires: ' . gmdate('D, d M Y H:i:s', time()) . ' GMT');
        header('Pragma: ');
        header('Accept-Ranges: none');
        header('Content-Type: application/json; charset=utf-8');

        echo json_encode($strings, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES);
        die;
    }

    /**
     * Send file not modified headers.
     *
     * @param int $lastmodified
     */
    protected function send_unmodified_headers($lastmodified): void {
        // 90 days only - based on Moodle point release cadence being every 3 months.
        $lifetime = 60 * 60 * 24 * 90;
        header('HTTP/1.1 304 Not Modified');
        header('Expires: ' . gmdate('D, d M Y H:i:s', time() + $lifetime) . ' GMT');
        header('Cache-Control: public, max-age=' . $lifetime);
        header('Content-Type: application/json; charset=utf-8');
        header('Etag: "' . $this->get_etag() . '"');
        if ($lastmodified) {
            header('Last-Modified: ' . gmdate('D, d M Y H:i:s', $lastmodified) . ' GMT');
        }
        die;
    }

    /**
     * Sends a 404 message to indicate that the content was not found.
     *
     * @param null|string $message An optional informative message to include to help debugging
     */
    protected function send_not_found(?string $message = null): void {
        header('HTTP/1.0 404 not found');

        if ($message) {
            die($message);
        } else {
            die('Language data was not found, sorry.');
        }
    }
};

$loader = new lang();