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/>.

/**
 * Class \core_h5p\editor_framework
 *
 * @package    core_h5p
 * @copyright  2020 Victor Deniz <victor@moodle.com>, base on code by Joubel AS
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

namespace core_h5p;

use Moodle\H5peditorStorage;
use stdClass;

/**
 * Moodle's implementation of the H5P Editor storage interface.
 *
 * Makes it possible for the editor's core library to communicate with the
 * database used by Moodle.
 *
 * @package    core_h5p
 * @copyright  2020 Victor Deniz <victor@moodle.com>, base on code by Joubel AS
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class editor_framework implements H5peditorStorage {

    /**
     * Retrieve library language file from file storage. Note that parent languages will also be checked until a matching
     * record is found (e.g. "de_kids" -> "de_du" -> "de")
     *
     * @param string $name
     * @param int $major
     * @param int $minor
     * @param string $lang
     * @return stdClass|bool Translation record if available, false otherwise
     */
    private function get_language_record(string $name, int $major, int $minor, string $lang) {
        global $DB;

        $params = [
            file_storage::COMPONENT,
            file_storage::LIBRARY_FILEAREA,
        ];
        $sqllike = $DB->sql_like('f.filepath', '?');
        $params[] = '%language%';

        $sql = "SELECT hl.id, f.pathnamehash
                  FROM {h5p_libraries} hl
             LEFT JOIN {files} f
                    ON hl.id = f.itemid AND f.component = ? AND f.filearea = ? AND $sqllike
                 WHERE ((hl.machinename = ? AND hl.majorversion = ? AND hl.minorversion = ?)
                   AND f.filename = ?)
              ORDER BY hl.patchversion DESC";

        $params[] = $name;
        $params[] = $major;
        $params[] = $minor;
        $params[] = $lang.'.json';

        // Add translations, based initially on the given H5P language code. If missing then recurse language dependencies
        // until we find a matching H5P language file.
        $result = $DB->get_record_sql($sql, $params);
        if ($result === false) {

            // Normalise Moodle language using underscore, as opposed to H5P which uses dash.
            $moodlelanguage = str_replace('-', '_', $lang);

            $dependencies = get_string_manager()->get_language_dependencies($moodlelanguage);

            // If current language has a dependency, then request it.
            if (count($dependencies) > 1) {
                $parentlanguage = get_html_lang_attribute_value($dependencies[count($dependencies) - 2]);
                $result = $this->get_language_record($name, $major, $minor, $parentlanguage);
            }
        }

        return $result;
    }

    /**
     * Load language file(JSON).
     * Used to translate the editor fields(title, description etc.)
     *
     * @param string $name The machine readable name of the library(content type)
     * @param int $major Major part of version number
     * @param int $minor Minor part of version number
     * @param string $lang Language code
     *
     * @return string|boolean Translation in JSON format if available, false otherwise
     */
    public function getLanguage($name, $major, $minor, $lang) {

        // Check if this information has been saved previously into the cache.
        $langcache = \cache::make('core', 'h5p_content_type_translations');
        $library = new stdClass();
        $library->machinename = $name;
        $library->majorversion = $major;
        $library->minorversion = $minor;
        $librarykey = helper::get_cache_librarykey(core::record_to_string($library));
        $cachekey = "{$librarykey}/{$lang}";
        $translation = $langcache->get($cachekey);

        if ($translation !== false) {
            // When there is no translation we store it in the cache as `null`.
            // This API requires it be returned as `false`.
            if ($translation === null) {
                return false;
            }

            return $translation;
        }

        // Get the language file for this library.
        $result = $this->get_language_record($name, $major, $minor, $lang);
        if (empty($result)) {
            // Save the fact that there is no translation into the cache.
            // The cache API cannot handle setting a literal `false` value so conver to `null` instead.
            $langcache->set($cachekey, null);

            return false;
        }

        // Save translation into the cache, and return its content.
        $fs = get_file_storage();
        $file = $fs->get_file_by_hash($result->pathnamehash);
        $translation = $file->get_content();

        $langcache->set($cachekey, $translation);

        return $translation;
    }

    /**
     * Load a list of available language codes.
     *
     * Until translations is implemented, only returns the "en" language.
     *
     * @param string $machinename The machine readable name of the library(content type)
     * @param int $major Major part of version number
     * @param int $minor Minor part of version number
     *
     * @return array List of possible language codes
     */
    public function getAvailableLanguages($machinename, $major, $minor): array {
        global $DB;

        // Check if this information has been saved previously into the cache.
        $langcache = \cache::make('core', 'h5p_content_type_translations');
        $library = new stdClass();
        $library->machinename = $machinename;
        $library->majorversion = $major;
        $library->minorversion = $minor;
        $librarykey = helper::get_cache_librarykey(core::record_to_string($library));
        $languages = $langcache->get($librarykey);
        if ($languages) {
            // This contains a list of all of the available languages for the library.
            return $languages;
        }

        // Get the language files for this library.
        $params = [
            file_storage::COMPONENT,
            file_storage::LIBRARY_FILEAREA,
        ];
        $filepathsqllike = $DB->sql_like('f.filepath', '?');
        $params[] = '%language%';
        $filenamesqllike = $DB->sql_like('f.filename', '?');
        $params[] = '%.json';

        $sql = "SELECT DISTINCT f.filename
                           FROM {h5p_libraries} hl
                      LEFT JOIN {files} f
                             ON hl.id = f.itemid AND f.component = ? AND f.filearea = ?
                            AND $filepathsqllike AND $filenamesqllike
                          WHERE hl.machinename = ? AND hl.majorversion = ? AND hl.minorversion = ?";
        $params[] = $machinename;
        $params[] = $major;
        $params[] = $minor;

        $defaultcode = 'en';
        $languages = [];

        $results = $DB->get_recordset_sql($sql, $params);
        if ($results->valid()) {
            // Extract the code language from the JS language files.
            foreach ($results as $result) {
                if (!empty($result->filename)) {
                    $lang = substr($result->filename, 0, -5);
                    $languages[$lang] = $languages;
                }
            }
            $results->close();

            // Semantics is 'en' by default. It has to be added always.
            if (!array_key_exists($defaultcode, $languages)) {
                $languages = array_keys($languages);
                array_unshift($languages, $defaultcode);
            }
        } else {
            $results->close();
            $params = [
                'machinename' => $machinename,
                'majorversion' => $major,
                'minorversion' => $minor,
            ];
            if ($DB->record_exists('h5p_libraries', $params)) {
                // If the library exists (but it doesn't contain any language file), at least defaultcode should be returned.
                $languages[] = $defaultcode;
            }
        }

        // Save available languages into the cache.
        $langcache->set($librarykey, $languages);

        return $languages;
    }

    /**
     * "Callback" for mark the given file as a permanent file.
     *
     * Used when saving content that has new uploaded files.
     *
     * @param int $fileid
     */
    public function keepFile($fileid): void {
        // Temporal files will be removed on a task when they are in the "editor" file area and and are at least one day older.
    }

    /**
     * Return libraries details.
     *
     * Two use cases:
     * 1. No input, will list all the available content types.
     * 2. Libraries supported are specified, load additional data and verify
     * that the content types are available. Used by e.g. the Presentation Tool
     * Editor that already knows which content types are supported in its
     * slides.
     *
     * @param array $libraries List of library names + version to load info for.
     *
     * @return array List of all libraries loaded.
     */
    public function getLibraries($libraries = null): ?array {

        if ($libraries !== null) {
            // Get details for the specified libraries.
            $librariesin = [];
            $fields = 'title, runnable, metadatasettings, example, tutorial';

            foreach ($libraries as $library) {
                $params = [
                    'machinename' => $library->name,
                    'majorversion' => $library->majorVersion,
                    'minorversion' => $library->minorVersion
                ];

                $details = api::get_library_details($params, true, $fields);

                if ($details) {
                    $library->title = $details->title;
                    $library->runnable = $details->runnable;
                    $library->metadataSettings = json_decode($details->metadatasettings ?? '');
                    $library->example = $details->example;
                    $library->tutorial = $details->tutorial;
                    $librariesin[] = $library;
                }
            }
        } else {
            $fields = 'id, machinename as name, title, majorversion, minorversion, metadatasettings, example, tutorial';
            $librariesin = api::get_contenttype_libraries($fields);
        }

        return $librariesin;
    }

    /**
     * Allow for other plugins to decide which styles and scripts are attached.
     *
     * This is useful for adding and/or modifying the functionality and look of
     * the content types.
     *
     * @param array $files List of files as objects with path and version as properties.
     * @param array $libraries List of libraries indexed by machineName with objects as values. The objects have majorVersion and
     *     minorVersion as properties.
     */
    public function alterLibraryFiles(&$files, $libraries): void {
        global $PAGE;

        // Refactor dependency list.
        $librarylist = [];
        foreach ($libraries as $dependency) {
            $librarylist[$dependency['machineName']] = [
                'majorVersion' => $dependency['majorVersion'],
                'minorVersion' => $dependency['minorVersion']
            ];
        }

        $renderer = $PAGE->get_renderer('core_h5p');

        $embedtype = 'editor';
        $renderer->h5p_alter_scripts($files['scripts'], $librarylist, $embedtype);
        $renderer->h5p_alter_styles($files['styles'], $librarylist, $embedtype);
    }

    /**
     * Saves a file or moves it temporarily.
     *
     * This is often necessary in order to validate and store uploaded or fetched H5Ps.
     *
     * @param string $data Uri of data that should be saved as a temporary file.
     * @param bool $movefile Can be set to TRUE to move the data instead of saving it.
     *
     * @return bool|object Returns false if saving failed or an object with path
     * of the directory and file that is temporarily saved.
     */
    public static function saveFileTemporarily($data, $movefile = false) {
        // This is to be implemented when the Hub client is used to upload libraries.
        return false;
    }

    /**
     * Marks a file for later cleanup.
     *
     * Useful when files are not instantly cleaned up. E.g. for files that are uploaded through the editor.
     *
     * @param int $file Id of file that should be cleaned up
     * @param int|null $contentid Content id of file
     */
    public static function markFileForCleanup($file, $contentid = null): ?int {
        // Temporal files will be removed on a task when they are in the "editor" file area and and are at least one day older.
        return null;
    }

    /**
     * Clean up temporary files
     *
     * @param string $filepath Path to file or directory
     */
    public static function removeTemporarilySavedFiles($filepath): void {
        // This is to be implemented when the Hub client is used to upload libraries.
    }
}