Your IP : 192.168.165.1
<?php
abstract class H5PEditorEndpoints {
/**
* Endpoint for retrieving library data necessary for displaying
* content types in the editor.
*/
const LIBRARIES = 'libraries';
/**
* Endpoint for retrieving a singe library's data necessary for displaying
* main libraries
*/
const SINGLE_LIBRARY = 'single-library';
/**
* Endpoint for retrieving the currently stored content type cache
*/
const CONTENT_TYPE_CACHE = 'content-type-cache';
/**
* Endpoint for retrieving the currently stored content hub metadata cache
*/
const CONTENT_HUB_METADATA_CACHE = 'content-hub-metadata-cache';
/**
* Endpoint for installing libraries from the Content Type Hub
*/
const LIBRARY_INSTALL = 'library-install';
/**
* Endpoint for uploading libraries used by the editor through the Content
* Type Hub.
*/
const LIBRARY_UPLOAD = 'library-upload';
/**
* Endpoint for uploading files used by the editor.
*/
const FILES = 'files';
/**
* Endpoint for retrieveing translation files
*/
const TRANSLATIONS = 'translations';
/**
* Endpoint for filtering parameters.
*/
const FILTER = 'filter';
/**
* Endpoint for installing libraries from the Content Type Hub
*/
const GET_HUB_CONTENT = 'get-hub-content';
}
/**
* Class H5PEditorAjax
* @package modules\h5peditor\h5peditor
*/
class H5PEditorAjax {
/**
* @var \H5PCore
*/
public $core;
/**
* @var \H5peditor
*/
public $editor;
/**
* @var \H5peditorStorage
*/
public $storage;
/**
* H5PEditorAjax constructor requires core, editor and storage as building
* blocks.
*
* @param H5PCore $H5PCore
* @param H5peditor $H5PEditor
* @param H5peditorStorage $H5PEditorStorage
*/
public function __construct(H5PCore $H5PCore, H5peditor $H5PEditor, H5peditorStorage $H5PEditorStorage) {
$this->core = $H5PCore;
$this->editor = $H5PEditor;
$this->storage = $H5PEditorStorage;
}
/**
* @param $endpoint
*/
public function action($endpoint) {
switch ($endpoint) {
case H5PEditorEndpoints::LIBRARIES:
H5PCore::ajaxSuccess($this->editor->getLibraries(), TRUE);
break;
case H5PEditorEndpoints::SINGLE_LIBRARY:
// pass on arguments
$args = func_get_args();
array_shift($args);
$library = call_user_func_array(
array($this->editor, 'getLibraryData'), $args
);
H5PCore::ajaxSuccess($library, TRUE);
break;
case H5PEditorEndpoints::CONTENT_TYPE_CACHE:
if (!$this->isHubOn()) return;
H5PCore::ajaxSuccess($this->getContentTypeCache(!$this->isContentTypeCacheUpdated()), TRUE);
break;
case H5PEditorEndpoints::CONTENT_HUB_METADATA_CACHE:
if (!$this->isHubOn()) return;
header('Cache-Control: no-cache');
header('Content-Type: application/json; charset=utf-8');
print '{"success":true,"data":' . $this->core->getUpdatedContentHubMetadataCache(func_get_arg(1)) . '}';
break;
case H5PEditorEndpoints::LIBRARY_INSTALL:
if (!$this->isPostRequest()) return;
$token = func_get_arg(1);
if (!$this->isValidEditorToken($token)) return;
$machineName = func_get_arg(2);
$this->libraryInstall($machineName);
break;
case H5PEditorEndpoints::LIBRARY_UPLOAD:
if (!$this->isPostRequest()) return;
$token = func_get_arg(1);
if (!$this->isValidEditorToken($token)) return;
$uploadPath = func_get_arg(2);
$contentId = func_get_arg(3);
$this->libraryUpload($uploadPath, $contentId);
break;
case H5PEditorEndpoints::FILES:
$token = func_get_arg(1);
$contentId = func_get_arg(2);
if (!$this->isValidEditorToken($token)) return;
$this->fileUpload($contentId);
break;
case H5PEditorEndpoints::TRANSLATIONS:
$language = func_get_arg(1);
H5PCore::ajaxSuccess($this->editor->getTranslations($_POST['libraries'], $language));
break;
case H5PEditorEndpoints::FILTER:
$token = func_get_arg(1);
if (!$this->isValidEditorToken($token)) return;
$this->filter(func_get_arg(2));
break;
case H5PEditorEndpoints::GET_HUB_CONTENT:
if (!$this->isPostRequest() || !$this->isValidEditorToken(func_get_arg(1))) {
return;
}
$this->getHubContent(func_get_arg(2), func_get_arg(3));
break;
}
}
/**
* Handles uploaded files from the editor, making sure they are validated
* and ready to be permanently stored if saved.
*
* Marks all uploaded files as
* temporary so they can be cleaned up when we have finished using them.
*
* @param int $contentId Id of content if already existing content
*/
private function fileUpload($contentId = NULL) {
$file = new H5peditorFile($this->core->h5pF);
if (!$file->isLoaded()) {
H5PCore::ajaxError($this->core->h5pF->t('File not found on server. Check file upload settings.'));
return;
}
// Make sure file is valid and mark it for cleanup at a later time
if ($file->validate()) {
$file_id = $this->core->fs->saveFile($file, 0);
$this->storage->markFileForCleanup($file_id, 0);
}
$file->printResult();
}
/**
* Handles uploading libraries so they are ready to be modified or directly saved.
*
* Validates and saves any dependencies, then exposes content to the editor.
*
* @param {string} $uploadFilePath Path to the file that should be uploaded
* @param {int} $contentId Content id of library
*/
private function libraryUpload($uploadFilePath, $contentId) {
// Verify h5p upload
if (!$uploadFilePath) {
H5PCore::ajaxError($this->core->h5pF->t('Could not get posted H5P.'), 'NO_CONTENT_TYPE');
exit;
}
$file = $this->saveFileTemporarily($uploadFilePath, TRUE);
if (!$file) return;
$this->processContent($contentId);
}
/**
* Process H5P content from local H5P package.
*
* @param integer $contentId The Local Content ID / vid. TODO Remove when JI-366 is fixed
*/
private function processContent($contentId) {
// Check if the downloaded package is valid
if (!$this->isValidPackage()) {
return; // Validation errors
}
// Install any required dependencies (libraries) from the package
// (if permission allows it, of course)
$storage = new H5PStorage($this->core->h5pF, $this->core);
$storage->savePackage(NULL, NULL, TRUE);
// Make content available to editor
$files = $this->core->fs->moveContentDirectory($this->core->h5pF->getUploadedH5pFolderPath(), $contentId);
// Clean up
$this->storage->removeTemporarilySavedFiles($this->core->h5pF->getUploadedH5pFolderPath());
// Mark all files as temporary
// TODO: Uncomment once moveContentDirectory() is fixed. JI-366
/*foreach ($files as $file) {
$this->storage->markFileForCleanup($file, 0);
}*/
H5PCore::ajaxSuccess(array(
'h5p' => $this->core->mainJsonData,
'content' => $this->core->contentJsonData,
'contentTypes' => $this->getContentTypeCache()
));
}
/**
* Validates security tokens used for the editor
*
* @param string $token
*
* @return bool
*/
private function isValidEditorToken($token) {
$isValidToken = $this->editor->ajaxInterface->validateEditorToken($token);
if (!$isValidToken) {
\H5PCore::ajaxError(
$this->core->h5pF->t('Invalid security token.'),
'INVALID_TOKEN'
);
return FALSE;
}
return TRUE;
}
/**
* Handles installation of libraries from the Content Type Hub.
*
* Accepts a machine name and attempts to fetch and install it from the Hub if
* it is valid. Will also install any dependencies to the requested library.
*
* @param string $machineName Name of library that should be installed
*/
private function libraryInstall($machineName) {
// Determine which content type to install from post data
if (!$machineName) {
H5PCore::ajaxError($this->core->h5pF->t('No content type was specified.'), 'NO_CONTENT_TYPE');
return;
}
// Look up content type to ensure it's valid(and to check permissions)
$contentType = $this->editor->ajaxInterface->getContentTypeCache($machineName);
if (!$contentType) {
H5PCore::ajaxError($this->core->h5pF->t('The chosen content type is invalid.'), 'INVALID_CONTENT_TYPE');
return;
}
// Check install permissions
if (!$this->editor->canInstallContentType($contentType)) {
H5PCore::ajaxError($this->core->h5pF->t('You do not have permission to install content types. Contact the administrator of your site.'), 'INSTALL_DENIED');
return;
}
else {
// Override core permission check
$this->core->mayUpdateLibraries(TRUE);
}
// Retrieve content type from hub endpoint
$response = $this->callHubEndpoint(H5PHubEndpoints::CONTENT_TYPES . $machineName);
if (!$response) return;
// Session parameters has to be set for validation and saving of packages
if (!$this->isValidPackage(TRUE)) return;
// Save H5P
$storage = new H5PStorage($this->core->h5pF, $this->core);
$storage->savePackage(NULL, NULL, TRUE);
// Clean up
$this->storage->removeTemporarilySavedFiles($this->core->h5pF->getUploadedH5pFolderPath());
// Successfully installed. Refresh content types
H5PCore::ajaxSuccess($this->getContentTypeCache());
}
/**
* End-point for filter parameter values according to semantics.
*
* @param {string} $libraryParameters
*/
private function filter($libraryParameters) {
$libraryParameters = json_decode($libraryParameters);
if (!$libraryParameters) {
H5PCore::ajaxError($this->core->h5pF->t('Could not parse post data.'), 'NO_LIBRARY_PARAMETERS');
exit;
}
// Filter parameters and send back to client
$validator = new H5PContentValidator($this->core->h5pF, $this->core);
$validator->validateLibrary($libraryParameters, (object) array('options' => array($libraryParameters->library)));
H5PCore::ajaxSuccess($libraryParameters);
}
/**
* Download and use content from the HUB
*
* @param integer $hubId The Hub Content ID
* @param integer $localContentId The Local Content ID
*/
private function getHubContent($hubId, $localContentId) {
// Download H5P file
if (!$this->callHubEndpoint(H5PHubEndpoints::CONTENT . '/' . $hubId . '/export')) {
return; // Download failed
}
$this->processContent($localContentId);
}
/**
* Validates the package. Sets error messages if validation fails.
*
* @param bool $skipContent Will not validate cotent if set to TRUE
*
* @return bool
*/
private function isValidPackage($skipContent = FALSE) {
$validator = new H5PValidator($this->core->h5pF, $this->core);
if (!$validator->isValidPackage($skipContent, FALSE)) {
$this->storage->removeTemporarilySavedFiles($this->core->h5pF->getUploadedH5pPath());
H5PCore::ajaxError(
$this->core->h5pF->t('Validating h5p package failed.'),
'VALIDATION_FAILED',
NULL,
$this->core->h5pF->getMessages('error')
);
return FALSE;
}
return TRUE;
}
/**
* Saves a file or moves it temporarily. This is often necessary in order to
* validate and store uploaded or fetched H5Ps.
*
* Sets error messages if saving fails.
*
* @param string $data Uri of data that should be saved as a temporary file
* @param boolean $move_file Can be set to TRUE to move the data instead of saving it
*
* @return bool|object Returns false if saving failed or the path to the file
* if saving succeeded
*/
private function saveFileTemporarily($data, $move_file = FALSE) {
$file = $this->storage->saveFileTemporarily($data, $move_file);
if (!$file) {
H5PCore::ajaxError(
$this->core->h5pF->t('Failed to download the requested H5P.'),
'DOWNLOAD_FAILED'
);
return FALSE;
}
return $file;
}
/**
* Calls provided hub endpoint and downloads the response to a .h5p file.
*
* @param string $endpoint Endpoint without protocol
*
* @return bool
*/
private function callHubEndpoint($endpoint) {
$path = $this->core->h5pF->getUploadedH5pPath();
$response = $this->core->h5pF->fetchExternalData(H5PHubEndpoints::createURL($endpoint), NULL, TRUE, empty($path) ? TRUE : $path);
if (!$response) {
H5PCore::ajaxError(
$this->core->h5pF->t('Failed to download the requested H5P.'),
'DOWNLOAD_FAILED',
NULL,
$this->core->h5pF->getMessages('error')
);
return FALSE;
}
return TRUE;
}
/**
* Checks if request is a POST. Sets error message on fail.
*
* @return bool
*/
private function isPostRequest() {
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
H5PCore::ajaxError(
$this->core->h5pF->t('A post message is required to access the given endpoint'),
'REQUIRES_POST',
405
);
return FALSE;
}
return TRUE;
}
/**
* Checks if H5P Hub is enabled. Sets error message on fail.
*
* @return bool
*/
private function isHubOn() {
if (!$this->core->h5pF->getOption('hub_is_enabled', TRUE)) {
H5PCore::ajaxError(
$this->core->h5pF->t('The hub is disabled. You can enable it in the H5P settings.'),
'HUB_DISABLED',
403
);
return false;
}
return true;
}
/**
* Checks if Content Type Cache is up to date. Immediately tries to fetch
* a new Content Type Cache if it is outdated.
* Sets error message if fetching new Content Type Cache fails.
*
* @return bool
*/
private function isContentTypeCacheUpdated() {
// Update content type cache if enabled and too old
$ct_cache_last_update = $this->core->h5pF->getOption('content_type_cache_updated_at', 0);
$outdated_cache = $ct_cache_last_update + (60 * 60 * 24 * 7); // 1 week
if (time() > $outdated_cache) {
$success = $this->core->updateContentTypeCache();
if (!$success) {
return false;
}
}
return true;
}
/**
* Gets content type cache for globally available libraries and the order
* in which they have been used by the author
*
* @param bool $cacheOutdated The cache is outdated and not able to update
*/
private function getContentTypeCache($cacheOutdated = FALSE) {
$canUpdateOrInstall = ($this->core->h5pF->hasPermission(H5PPermission::INSTALL_RECOMMENDED) ||
$this->core->h5pF->hasPermission(H5PPermission::UPDATE_LIBRARIES));
return array(
'outdated' => $cacheOutdated && $canUpdateOrInstall,
'libraries' => $this->editor->getLatestGlobalLibrariesData(),
'recentlyUsed' => $this->editor->ajaxInterface->getAuthorsRecentlyUsedLibraries(),
'apiVersion' => array(
'major' => H5PCore::$coreApi['majorVersion'],
'minor' => H5PCore::$coreApi['minorVersion']
),
'details' => $this->core->h5pF->getMessages('info')
);
}
}