<?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\file_storage.
*
* @package core_h5p
* @copyright 2019 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 stored_file;
use Moodle\H5PCore;
use Moodle\H5peditorFile;
use Moodle\H5PFileStorage;
// phpcs:disable moodle.NamingConventions.ValidFunctionName.LowercaseMethod
/**
* Class to handle storage and export of H5P Content.
*
* @package core_h5p
* @copyright 2019 Victor Deniz <victor@moodle.com>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class file_storage implements H5PFileStorage {
/** The component for H5P. */
public const COMPONENT = 'core_h5p';
/** The library file area. */
public const LIBRARY_FILEAREA = 'libraries';
/** The content file area */
public const CONTENT_FILEAREA = 'content';
/** The cached assest file area. */
public const CACHED_ASSETS_FILEAREA = 'cachedassets';
/** The export file area */
public const EXPORT_FILEAREA = 'export';
/** The export css file area */
public const CSS_FILEAREA = 'css';
/** The icon filename */
public const ICON_FILENAME = 'icon.svg';
/** The custom CSS filename */
private const CUSTOM_CSS_FILENAME = 'custom_h5p.css';
/**
* @var \context $context Currently we use the system context everywhere.
* Don't feel forced to keep it this way in the future.
*/
protected $context;
/** @var \file_storage $fs File storage. */
protected $fs;
/**
* Initial setup for file_storage.
*/
public function __construct() {
// Currently everything uses the system context.
$this->context = \context_system::instance();
$this->fs = get_file_storage();
}
/**
* Stores a H5P library in the Moodle filesystem.
*
* @param array $library Library properties.
*/
public function saveLibrary($library) {
$options = [
'contextid' => $this->context->id,
'component' => self::COMPONENT,
'filearea' => self::LIBRARY_FILEAREA,
'filepath' => '/' . H5PCore::libraryToFolderName($library) . '/',
'itemid' => $library['libraryId'],
];
// Easiest approach: delete the existing library version and copy the new one.
$this->delete_library($library);
$this->copy_directory($library['uploadDirectory'], $options);
}
/**
* Delete library folder.
*
* @param array $library
*/
public function deleteLibrary($library) {
// Although this class had a method (delete_library()) for removing libraries before this was added to the interface,
// it's not safe to call it from here because looking at the place where it's called, it's not clear what are their
// expectation. This method will be implemented once more information will be added to the H5P technical doc.
}
/**
* Store the content folder.
*
* @param string $source Path on file system to content directory.
* @param array $content Content properties
*/
public function saveContent($source, $content) {
$options = [
'contextid' => $this->context->id,
'component' => self::COMPONENT,
'filearea' => self::CONTENT_FILEAREA,
'itemid' => $content['id'],
'filepath' => '/',
];
$this->delete_directory($this->context->id, self::COMPONENT, self::CONTENT_FILEAREA, $content['id']);
// Copy content directory into Moodle filesystem.
$this->copy_directory($source, $options);
}
/**
* Remove content folder.
*
* @param array $content Content properties
*/
public function deleteContent($content) {
$this->delete_directory($this->context->id, self::COMPONENT, self::CONTENT_FILEAREA, $content['id']);
}
/**
* Creates a stored copy of the content folder.
*
* @param string $id Identifier of content to clone.
* @param int $newid The cloned content's identifier
*/
public function cloneContent($id, $newid) {
// Not implemented in Moodle.
}
/**
* Get path to a new unique tmp folder.
* Please note this needs to not be a directory.
*
* @return string Path
*/
public function getTmpPath(): string {
return make_request_directory() . '/' . uniqid('h5p-');
}
/**
* Fetch content folder and save in target directory.
*
* @param int $id Content identifier
* @param string $target Where the content folder will be saved
*/
public function exportContent($id, $target) {
$this->export_file_tree($target, $this->context->id, self::CONTENT_FILEAREA, '/', $id);
}
/**
* Fetch library folder and save in target directory.
*
* @param array $library Library properties
* @param string $target Where the library folder will be saved
*/
public function exportLibrary($library, $target) {
$folder = H5PCore::libraryToFolderName($library);
$this->export_file_tree($target . '/' . $folder, $this->context->id, self::LIBRARY_FILEAREA,
'/' . $folder . '/', $library['libraryId']);
}
/**
* Save export in file system
*
* @param string $source Path on file system to temporary export file.
* @param string $filename Name of export file.
*/
public function saveExport($source, $filename) {
global $USER;
// Remove old export.
$this->deleteExport($filename);
$filerecord = [
'contextid' => $this->context->id,
'component' => self::COMPONENT,
'filearea' => self::EXPORT_FILEAREA,
'itemid' => 0,
'filepath' => '/',
'filename' => $filename,
'userid' => $USER->id
];
$this->fs->create_file_from_pathname($filerecord, $source);
}
/**
* Removes given export file
*
* @param string $filename filename of the export to delete.
*/
public function deleteExport($filename) {
$file = $this->get_export_file($filename);
if ($file) {
$file->delete();
}
}
/**
* Check if the given export file exists
*
* @param string $filename The export file to check.
* @return boolean True if the export file exists.
*/
public function hasExport($filename) {
return !!$this->get_export_file($filename);
}
/**
* Will concatenate all JavaScrips and Stylesheets into two files in order
* to improve page performance.
*
* @param array $files A set of all the assets required for content to display
* @param string $key Hashed key for cached asset
*/
public function cacheAssets(&$files, $key) {
foreach ($files as $type => $assets) {
if (empty($assets)) {
continue;
}
// Create new file for cached assets.
$ext = ($type === 'scripts' ? 'js' : 'css');
$filename = $key . '.' . $ext;
$fileinfo = [
'contextid' => $this->context->id,
'component' => self::COMPONENT,
'filearea' => self::CACHED_ASSETS_FILEAREA,
'itemid' => 0,
'filepath' => '/',
'filename' => $filename
];
// Store concatenated content.
$this->fs->create_file_from_string($fileinfo, $this->concatenate_files($assets, $type, $this->context));
$files[$type] = [
(object) [
'path' => '/' . self::CACHED_ASSETS_FILEAREA . '/' . $filename,
'version' => ''
]
];
}
}
/**
* Will check if there are cache assets available for content.
*
* @param string $key Hashed key for cached asset
* @return array
*/
public function getCachedAssets($key) {
$files = [];
$js = $this->fs->get_file($this->context->id, self::COMPONENT, self::CACHED_ASSETS_FILEAREA, 0, '/', "{$key}.js");
if ($js && $js->get_filesize() > 0) {
$files['scripts'] = [
(object) [
'path' => '/' . self::CACHED_ASSETS_FILEAREA . '/' . "{$key}.js",
'version' => ''
]
];
}
$css = $this->fs->get_file($this->context->id, self::COMPONENT, self::CACHED_ASSETS_FILEAREA, 0, '/', "{$key}.css");
if ($css && $css->get_filesize() > 0) {
$files['styles'] = [
(object) [
'path' => '/' . self::CACHED_ASSETS_FILEAREA . '/' . "{$key}.css",
'version' => ''
]
];
}
return empty($files) ? null : $files;
}
/**
* Remove the aggregated cache files.
*
* @param array $keys The hash keys of removed files
*/
public function deleteCachedAssets($keys) {
if (empty($keys)) {
return;
}
foreach ($keys as $hash) {
foreach (['js', 'css'] as $type) {
$cachedasset = $this->fs->get_file($this->context->id, self::COMPONENT, self::CACHED_ASSETS_FILEAREA, 0, '/',
"{$hash}.{$type}");
if ($cachedasset) {
$cachedasset->delete();
}
}
}
}
/**
* Read file content of given file and then return it.
*
* @param string $filepath
* @return string contents
*/
public function getContent($filepath) {
list(
'filearea' => $filearea,
'filepath' => $filepath,
'filename' => $filename,
'itemid' => $itemid
) = $this->get_file_elements_from_filepath($filepath);
if (!$itemid) {
throw new \file_serving_exception('Could not retrieve the requested file, check your file permissions.');
}
// Locate file.
$file = $this->fs->get_file($this->context->id, self::COMPONENT, $filearea, $itemid, $filepath, $filename);
// Return content.
return $file->get_content();
}
/**
* Save files uploaded through the editor.
*
* @param H5peditorFile $file
* @param int $contentid
*
* @return int The id of the saved file.
*/
public function saveFile($file, $contentid) {
global $USER;
$context = $this->context->id;
$component = self::COMPONENT;
$filearea = self::CONTENT_FILEAREA;
if ($contentid === 0) {
$usercontext = \context_user::instance($USER->id);
$context = $usercontext->id;
$component = 'user';
$filearea = 'draft';
}
$record = array(
'contextid' => $context,
'component' => $component,
'filearea' => $filearea,
'itemid' => $contentid,
'filepath' => '/' . $file->getType() . 's/',
'filename' => $file->getName()
);
$storedfile = $this->fs->create_file_from_pathname($record, $_FILES['file']['tmp_name']);
return $storedfile->get_id();
}
/**
* Copy a file from another content or editor tmp dir.
* Used when copy pasting content in H5P.
*
* @param string $file path + name
* @param string|int $fromid Content ID or 'editor' string
* @param \stdClass $tocontent Target Content
*
* @return void
*/
public function cloneContentFile($file, $fromid, $tocontent): void {
// Determine source filearea and itemid.
if ($fromid === 'editor') {
$sourcefilearea = 'draft';
$sourceitemid = 0;
} else {
$sourcefilearea = self::CONTENT_FILEAREA;
$sourceitemid = (int)$fromid;
}
$filepath = '/' . dirname($file) . '/';
$filename = basename($file);
// Check to see if source exists.
$sourcefile = $this->get_file($sourcefilearea, $sourceitemid, $file);
if ($sourcefile === null) {
return; // Nothing to copy from.
}
// Check to make sure that file doesn't exist already in target.
$targetfile = $this->get_file(self::CONTENT_FILEAREA, $tocontent->id, $file);
if ( $targetfile !== null) {
return; // File exists, no need to copy.
}
// Create new file record.
$record = [
'contextid' => $this->context->id,
'component' => self::COMPONENT,
'filearea' => self::CONTENT_FILEAREA,
'itemid' => $tocontent->id,
'filepath' => $filepath,
'filename' => $filename,
];
$this->fs->create_file_from_storedfile($record, $sourcefile);
}
/**
* Copy content from one directory to another.
* Defaults to cloning content from the current temporary upload folder to the editor path.
*
* @param string $source path to source directory
* @param string $contentid Id of content
*
*/
public function moveContentDirectory($source, $contentid = null) {
$contentidint = (int)$contentid;
if ($source === null) {
return;
}
// Get H5P and content json.
$contentsource = $source . '/content';
// Move all temporary content files to editor.
$it = new \RecursiveIteratorIterator(
new \RecursiveDirectoryIterator($contentsource, \RecursiveDirectoryIterator::SKIP_DOTS),
\RecursiveIteratorIterator::SELF_FIRST
);
$it->rewind();
while ($it->valid()) {
$item = $it->current();
$pathname = $it->getPathname();
if (!$item->isDir() && !($item->getFilename() === 'content.json')) {
$this->move_file($pathname, $contentidint);
}
$it->next();
}
}
/**
* Get the file URL or given library and then return it.
*
* @param int $itemid
* @param string $machinename
* @param int $majorversion
* @param int $minorversion
* @return string url or false if the file doesn't exist
*/
public function get_icon_url(int $itemid, string $machinename, int $majorversion, int $minorversion) {
$filepath = '/' . "{$machinename}-{$majorversion}.{$minorversion}" . '/';
if ($file = $this->fs->get_file(
$this->context->id,
self::COMPONENT,
self::LIBRARY_FILEAREA,
$itemid,
$filepath,
self::ICON_FILENAME)
) {
$iconurl = \moodle_url::make_pluginfile_url(
$this->context->id,
self::COMPONENT,
self::LIBRARY_FILEAREA,
$itemid,
$filepath,
$file->get_filename());
// Return image URL.
return $iconurl->out();
}
return false;
}
/**
* Checks to see if an H5P content has the given file.
*
* @param string $file File path and name.
* @param int $content Content id.
*
* @return int|null File ID or NULL if not found
*/
public function getContentFile($file, $content): ?int {
if (is_object($content)) {
$content = $content->id;
}
$contentfile = $this->get_file(self::CONTENT_FILEAREA, $content, $file);
return ($contentfile === null ? null : $contentfile->get_id());
}
/**
* Remove content files that are no longer used.
*
* Used when saving content.
*
* @param string $file File path and name.
* @param int $contentid Content id.
*
* @return void
*/
public function removeContentFile($file, $contentid): void {
// Although the interface defines $contentid as int, object given in H5peditor::processParameters.
if (is_object($contentid)) {
$contentid = $contentid->id;
}
$existingfile = $this->get_file(self::CONTENT_FILEAREA, $contentid, $file);
if ($existingfile !== null) {
$existingfile->delete();
}
}
/**
* Check if server setup has write permission to
* the required folders
*
* @return bool True if server has the proper write access
*/
public function hasWriteAccess() {
// Moodle has access to the files table which is where all of the folders are stored.
return true;
}
/**
* Check if the library has a presave.js in the root folder
*
* @param string $libraryname
* @param string $developmentpath
* @return bool
*/
public function hasPresave($libraryname, $developmentpath = null) {
return false;
}
/**
* Check if upgrades script exist for library.
*
* @param string $machinename
* @param int $majorversion
* @param int $minorversion
* @return string Relative path
*/
public function getUpgradeScript($machinename, $majorversion, $minorversion) {
$path = '/' . "{$machinename}-{$majorversion}.{$minorversion}" . '/';
$file = 'upgrade.js';
$itemid = $this->get_itemid_for_file(self::LIBRARY_FILEAREA, $path, $file);
if ($this->fs->get_file($this->context->id, self::COMPONENT, self::LIBRARY_FILEAREA, $itemid, $path, $file)) {
return '/' . self::LIBRARY_FILEAREA . $path. $file;
} else {
return null;
}
}
/**
* Store the given stream into the given file.
*
* @param string $path
* @param string $file
* @param resource $stream
* @return bool|int
*/
public function saveFileFromZip($path, $file, $stream) {
$fullpath = $path . '/' . $file;
check_dir_exists(pathinfo($fullpath, PATHINFO_DIRNAME));
return file_put_contents($fullpath, $stream);
}
/**
* Deletes a library from the file system.
*
* @param array $library Library details
*/
public function delete_library(array $library): void {
global $DB;
// A library ID of false would result in all library files being deleted, which we don't want. Return instead.
if (empty($library['libraryId'])) {
return;
}
$areafiles = $this->fs->get_area_files($this->context->id, self::COMPONENT, self::LIBRARY_FILEAREA, $library['libraryId']);
$this->delete_directory($this->context->id, self::COMPONENT, self::LIBRARY_FILEAREA, $library['libraryId']);
$librarycache = \cache::make('core', 'h5p_library_files');
foreach ($areafiles as $file) {
if (!$DB->record_exists('files', array('contenthash' => $file->get_contenthash(),
'component' => self::COMPONENT,
'filearea' => self::LIBRARY_FILEAREA))) {
$librarycache->delete($file->get_contenthash());
}
}
}
/**
* Remove an H5P directory from the filesystem.
*
* @param int $contextid context ID
* @param string $component component
* @param string $filearea file area or all areas in context if not specified
* @param int $itemid item ID or all files if not specified
*/
private function delete_directory(int $contextid, string $component, string $filearea, int $itemid): void {
$this->fs->delete_area_files($contextid, $component, $filearea, $itemid);
}
/**
* Copy an H5P directory from the temporary directory into the file system.
*
* @param string $source Temporary location for files.
* @param array $options File system information.
*/
private function copy_directory(string $source, array $options): void {
$librarycache = \cache::make('core', 'h5p_library_files');
$it = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($source, \RecursiveDirectoryIterator::SKIP_DOTS),
\RecursiveIteratorIterator::SELF_FIRST);
$root = $options['filepath'];
$it->rewind();
while ($it->valid()) {
$item = $it->current();
$subpath = $it->getSubPath();
if (!$item->isDir()) {
$options['filename'] = $it->getFilename();
if (!$subpath == '') {
$options['filepath'] = $root . $subpath . '/';
} else {
$options['filepath'] = $root;
}
$file = $this->fs->create_file_from_pathname($options, $item->getPathName());
if ($options['filearea'] == self::LIBRARY_FILEAREA) {
if (!$librarycache->has($file->get_contenthash())) {
$librarycache->set($file->get_contenthash(), file_get_contents($item->getPathName()));
}
}
}
$it->next();
}
}
/**
* Copies files from storage to temporary folder.
*
* @param string $target Path to temporary folder
* @param int $contextid context where the files are found
* @param string $filearea file area
* @param string $filepath file path
* @param int $itemid Optional item ID
*/
private function export_file_tree(string $target, int $contextid, string $filearea, string $filepath, int $itemid = 0): void {
// Make sure target folder exists.
check_dir_exists($target);
// Read source files.
$files = $this->fs->get_directory_files($contextid, self::COMPONENT, $filearea, $itemid, $filepath, true);
$librarycache = \cache::make('core', 'h5p_library_files');
foreach ($files as $file) {
$path = $target . str_replace($filepath, DIRECTORY_SEPARATOR, $file->get_filepath());
if ($file->is_directory()) {
check_dir_exists(rtrim($path));
} else {
if ($filearea == self::LIBRARY_FILEAREA) {
$cachedfile = $librarycache->get($file->get_contenthash());
if (empty($cachedfile)) {
$file->copy_content_to($path . $file->get_filename());
$librarycache->set($file->get_contenthash(), file_get_contents($path . $file->get_filename()));
} else {
file_put_contents($path . $file->get_filename(), $cachedfile);
}
} else {
$file->copy_content_to($path . $file->get_filename());
}
}
}
}
/**
* Adds all files of a type into one file.
*
* @param array $assets A list of files.
* @param string $type The type of files in assets. Either 'scripts' or 'styles'
* @param \context $context Context
* @return string All of the file content in one string.
*/
private function concatenate_files(array $assets, string $type, \context $context): string {
$content = '';
foreach ($assets as $asset) {
// Find location of asset.
list(
'filearea' => $filearea,
'filepath' => $filepath,
'filename' => $filename,
'itemid' => $itemid
) = $this->get_file_elements_from_filepath($asset->path);
if ($itemid === false) {
continue;
}
// Locate file.
$file = $this->fs->get_file($context->id, self::COMPONENT, $filearea, $itemid, $filepath, $filename);
// Get file content and concatenate.
if ($type === 'scripts') {
$content .= $file->get_content() . ";\n";
} else {
// Rewrite relative URLs used inside stylesheets.
$content .= preg_replace_callback(
'/url\([\'"]?([^"\')]+)[\'"]?\)/i',
function ($matches) use ($filearea, $filepath, $itemid) {
if (preg_match("/^(data:|([a-z0-9]+:)?\/)/i", $matches[1]) === 1) {
return $matches[0]; // Not relative, skip.
}
// Find "../" in matches[1].
// If it exists, we have to remove "../".
// And switch the last folder in the filepath for the first folder in $matches[1].
// For instance:
// $filepath: /H5P.Question-1.4/styles/
// $matches[1]: ../images/plus-one.svg
// We want to avoid this: H5P.Question-1.4/styles/ITEMID/../images/minus-one.svg
// We want this: H5P.Question-1.4/images/ITEMID/minus-one.svg.
if (preg_match('/\.\.\//', $matches[1], $pathmatches)) {
$path = preg_split('/\//', $filepath, -1, PREG_SPLIT_NO_EMPTY);
$pathfilename = preg_split('/\//', $matches[1], -1, PREG_SPLIT_NO_EMPTY);
// Remove the first element: ../.
array_shift($pathfilename);
// Replace pathfilename into the filepath.
$path[count($path) - 1] = $pathfilename[0];
$filepath = '/' . implode('/', $path) . '/';
// Remove the element used to replace.
array_shift($pathfilename);
$matches[1] = implode('/', $pathfilename);
}
return 'url("../' . $filearea . $filepath . $itemid . '/' . $matches[1] . '")';
},
$file->get_content()) . "\n";
}
}
return $content;
}
/**
* Get files ready for export.
*
* @param string $filename File name to retrieve.
* @return bool|\stored_file Stored file instance if exists, false if not
*/
public function get_export_file(string $filename) {
return $this->fs->get_file($this->context->id, self::COMPONENT, self::EXPORT_FILEAREA, 0, '/', $filename);
}
/**
* Converts a relative system file path into Moodle File API elements.
*
* @param string $filepath The system filepath to get information from.
* @return array File information.
*/
private function get_file_elements_from_filepath(string $filepath): array {
$sections = explode('/', $filepath);
// Get the filename.
$filename = array_pop($sections);
// Discard first element.
if (empty($sections[0])) {
array_shift($sections);
}
// Get the filearea.
$filearea = array_shift($sections);
$itemid = array_shift($sections);
// Get the filepath.
$filepath = implode('/', $sections);
$filepath = '/' . $filepath . '/';
return ['filearea' => $filearea, 'filepath' => $filepath, 'filename' => $filename, 'itemid' => $itemid];
}
/**
* Returns the item id given the other necessary variables.
*
* @param string $filearea The file area.
* @param string $filepath The file path.
* @param string $filename The file name.
* @return mixed the specified value false if not found.
*/
private function get_itemid_for_file(string $filearea, string $filepath, string $filename) {
global $DB;
return $DB->get_field('files', 'itemid', ['component' => self::COMPONENT, 'filearea' => $filearea, 'filepath' => $filepath,
'filename' => $filename]);
}
/**
* Helper to make it easy to load content files.
*
* @param string $filearea File area where the file is saved.
* @param int $itemid Content instance or content id.
* @param string $file File path and name.
*
* @return stored_file|null
*/
private function get_file(string $filearea, int $itemid, string $file): ?stored_file {
global $USER;
$component = self::COMPONENT;
$context = $this->context->id;
if ($filearea === 'draft') {
$itemid = 0;
$component = 'user';
$usercontext = \context_user::instance($USER->id);
$context = $usercontext->id;
}
$filepath = '/'. dirname($file). '/';
$filename = basename($file);
// Load file.
$existingfile = $this->fs->get_file($context, $component, $filearea, $itemid, $filepath, $filename);
if (!$existingfile) {
return null;
}
return $existingfile;
}
/**
* Move a single file
*
* @param string $sourcefile Path to source file
* @param int $contentid Content id or 0 if the file is in the editor file area
*
* @return void
*/
private function move_file(string $sourcefile, int $contentid): void {
$pathparts = pathinfo($sourcefile);
$filename = $pathparts['basename'];
$filepath = $pathparts['dirname'];
$foldername = basename($filepath);
// Create file record for content.
$record = array(
'contextid' => $this->context->id,
'component' => $contentid > 0 ? self::COMPONENT : 'user',
'filearea' => $contentid > 0 ? self::CONTENT_FILEAREA : 'draft',
'itemid' => $contentid > 0 ? $contentid : 0,
'filepath' => '/' . $foldername . '/',
'filename' => $filename
);
$file = $this->fs->get_file(
$record['contextid'], $record['component'],
$record['filearea'], $record['itemid'], $record['filepath'],
$record['filename']
);
if ($file) {
// Delete it to make sure that it is replaced with correct content.
$file->delete();
}
$this->fs->create_file_from_pathname($record, $sourcefile);
}
/**
* Generate H5P custom styles if any.
*/
public static function generate_custom_styles(): void {
$record = self::get_custom_styles_file_record();
$cssfile = self::get_custom_styles_file($record);
if ($cssfile) {
// The CSS file needs to be updated, so delete and recreate it
// if there is CSS in the 'h5pcustomcss' setting.
$cssfile->delete();
}
$css = get_config('core_h5p', 'h5pcustomcss');
if (!empty($css)) {
$fs = get_file_storage();
$fs->create_file_from_string($record, $css);
}
}
/**
* Get H5P custom styles if any.
*
* @throws \moodle_exception If the CSS setting is empty but there is a file to serve
* or there is no file but the CSS setting is not empty.
* @return array|null If there is CSS then an array with the keys 'cssurl'
* and 'cssversion' is returned otherwise null. 'cssurl' is a link to the
* generated 'custom_h5p.css' file and 'cssversion' the md5 hash of its contents.
*/
public static function get_custom_styles(): ?array {
$record = self::get_custom_styles_file_record();
$css = get_config('core_h5p', 'h5pcustomcss');
if (self::get_custom_styles_file($record)) {
if (empty($css)) {
// The custom CSS file exists and yet the setting 'h5pcustomcss' is empty.
// This prevents an invalid content hash.
throw new \moodle_exception(
'The H5P \'h5pcustomcss\' setting is empty and yet the custom CSS file \''.
$record['filename'].
'\' exists.',
'core_h5p'
);
}
// File exists, so generate the url and version hash.
$cssurl = \moodle_url::make_pluginfile_url(
$record['contextid'],
$record['component'],
$record['filearea'],
null,
$record['filepath'],
$record['filename']
);
return ['cssurl' => $cssurl, 'cssversion' => md5($css)];
} else if (!empty($css)) {
// The custom CSS file does not exist and yet should do.
throw new \moodle_exception(
'The H5P custom CSS file \''.
$record['filename'].
'\' does not exist and yet there is CSS in the \'h5pcustomcss\' setting.',
'core_h5p'
);
}
return null;
}
/**
* Get H5P custom styles file record.
*
* @return array File record for the CSS custom styles.
*/
private static function get_custom_styles_file_record(): array {
return [
'contextid' => \context_system::instance()->id,
'component' => self::COMPONENT,
'filearea' => self::CSS_FILEAREA,
'itemid' => 0,
'filepath' => '/',
'filename' => self::CUSTOM_CSS_FILENAME,
];
}
/**
* Get H5P custom styles file.
*
* @param array $record The H5P custom styles file record.
*
* @return stored_file|bool stored_file instance if exists, false if not.
*/
private static function get_custom_styles_file($record): stored_file|bool {
$fs = get_file_storage();
return $fs->get_file(
$record['contextid'],
$record['component'],
$record['filearea'],
$record['itemid'],
$record['filepath'],
$record['filename']
);
}
}