Your IP : 192.168.165.1
<?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/>.
/**
* Definition of a class stored_file.
*
* @package core_files
* @copyright 2008 Petr Skoda {@link http://skodak.org}
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
require_once($CFG->dirroot . '/lib/filestorage/file_progress.php');
require_once($CFG->dirroot . '/lib/filestorage/file_system.php');
/**
* Class representing local files stored in a sha1 file pool.
*
* Since Moodle 2.0 file contents are stored in sha1 pool and
* all other file information is stored in new "files" database table.
*
* @package core_files
* @category files
* @copyright 2008 Petr Skoda {@link http://skodak.org}
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @since Moodle 2.0
*/
class stored_file {
/** @var file_storage file storage pool instance */
private $fs;
/** @var stdClass record from the files table left join files_reference table */
private $file_record;
/** @var repository repository plugin instance */
private $repository;
/** @var file_system filesystem instance */
private $filesystem;
/**
* @var int Indicates a file handle of the type returned by fopen.
*/
const FILE_HANDLE_FOPEN = 0;
/**
* @var int Indicates a file handle of the type returned by gzopen.
*/
const FILE_HANDLE_GZOPEN = 1;
/**
* Constructor, this constructor should be called ONLY from the file_storage class!
*
* @param file_storage $fs file storage instance
* @param stdClass $file_record description of file
* @param string $deprecated
*/
public function __construct(file_storage $fs, stdClass $file_record, $deprecated = null) {
global $DB, $CFG;
$this->fs = $fs;
$this->file_record = clone($file_record); // prevent modifications
if (!empty($file_record->repositoryid)) {
require_once("$CFG->dirroot/repository/lib.php");
$this->repository = repository::get_repository_by_id($file_record->repositoryid, SYSCONTEXTID);
if ($this->repository->supported_returntypes() & FILE_REFERENCE != FILE_REFERENCE) {
// Repository cannot do file reference.
throw new moodle_exception('error');
}
} else {
$this->repository = null;
}
// make sure all reference fields exist in file_record even when it is not a reference
foreach (array('referencelastsync', 'referencefileid', 'reference', 'repositoryid') as $key) {
if (empty($this->file_record->$key)) {
$this->file_record->$key = null;
}
}
$this->filesystem = $fs->get_file_system();
}
/**
* Magic method, called during serialization.
*
* @return array
*/
public function __sleep() {
// We only ever want the file_record saved, not the file_storage object.
return ['file_record'];
}
/**
* Magic method, called during unserialization.
*/
public function __wakeup() {
// Recreate our stored_file based on the file_record, and using file storage retrieved the correct way.
$this->__construct(get_file_storage(), $this->file_record);
}
/**
* Whether or not this is a external resource
*
* @return bool
*/
public function is_external_file() {
return !empty($this->repository);
}
/**
* Whether or not this is a controlled link. Note that repositories cannot support FILE_REFERENCE and FILE_CONTROLLED_LINK.
*
* @return bool
*/
public function is_controlled_link() {
return $this->is_external_file() && $this->repository->supported_returntypes() & FILE_CONTROLLED_LINK;
}
/**
* Update some file record fields
* NOTE: Must remain protected
*
* @param stdClass $dataobject
*/
protected function update($dataobject) {
global $DB;
$updatereferencesneeded = false;
$updatemimetype = false;
$keys = array_keys((array)$this->file_record);
$filepreupdate = clone($this->file_record);
foreach ($dataobject as $field => $value) {
if (in_array($field, $keys)) {
if ($field == 'contextid' and (!is_number($value) or $value < 1)) {
throw new file_exception('storedfileproblem', 'Invalid contextid');
}
if ($field == 'component') {
$value = clean_param($value, PARAM_COMPONENT);
if (empty($value)) {
throw new file_exception('storedfileproblem', 'Invalid component');
}
}
if ($field == 'filearea') {
$value = clean_param($value, PARAM_AREA);
if (empty($value)) {
throw new file_exception('storedfileproblem', 'Invalid filearea');
}
}
if ($field == 'itemid' and (!is_number($value) or $value < 0)) {
throw new file_exception('storedfileproblem', 'Invalid itemid');
}
if ($field == 'filepath') {
$value = clean_param($value, PARAM_PATH);
if (strpos($value, '/') !== 0 or strrpos($value, '/') !== strlen($value)-1) {
// path must start and end with '/'
throw new file_exception('storedfileproblem', 'Invalid file path');
}
}
if ($field == 'filename') {
// folder has filename == '.', so we pass this
if ($value != '.') {
$value = clean_param($value, PARAM_FILE);
}
if ($value === '') {
throw new file_exception('storedfileproblem', 'Invalid file name');
}
}
if ($field === 'timecreated' or $field === 'timemodified') {
if (!is_number($value)) {
throw new file_exception('storedfileproblem', 'Invalid timestamp');
}
if ($value < 0) {
$value = 0;
}
}
if ($field === 'referencefileid') {
if (!is_null($value) and !is_number($value)) {
throw new file_exception('storedfileproblem', 'Invalid reference info');
}
}
if (($field == 'contenthash' || $field == 'filesize') && $this->file_record->$field != $value) {
$updatereferencesneeded = true;
}
if ($updatereferencesneeded || ($field === 'filename' && $this->file_record->filename != $value)) {
$updatemimetype = true;
}
// adding the field
$this->file_record->$field = $value;
} else {
throw new coding_exception("Invalid field name, $field doesn't exist in file record");
}
}
// Validate mimetype field
if ($updatemimetype) {
$mimetype = $this->filesystem->mimetype_from_storedfile($this);
$this->file_record->mimetype = $mimetype;
}
$DB->update_record('files', $this->file_record);
if ($updatereferencesneeded) {
// Either filesize or contenthash of this file have changed. Update all files that reference to it.
$this->fs->update_references_to_storedfile($this);
}
// Callback for file update.
if (!$this->is_directory()) {
if ($pluginsfunction = get_plugins_with_function('after_file_updated')) {
foreach ($pluginsfunction as $plugintype => $plugins) {
foreach ($plugins as $pluginfunction) {
$pluginfunction($this->file_record, $filepreupdate);
}
}
}
}
}
/**
* Rename filename
*
* @param string $filepath file path
* @param string $filename file name
*/
public function rename($filepath, $filename) {
if ($this->fs->file_exists($this->get_contextid(), $this->get_component(), $this->get_filearea(), $this->get_itemid(), $filepath, $filename)) {
$a = new stdClass();
$a->contextid = $this->get_contextid();
$a->component = $this->get_component();
$a->filearea = $this->get_filearea();
$a->itemid = $this->get_itemid();
$a->filepath = $filepath;
$a->filename = $filename;
throw new file_exception('storedfilenotcreated', $a, 'file exists, cannot rename');
}
$filerecord = new stdClass;
$filerecord->filepath = $filepath;
$filerecord->filename = $filename;
// populate the pathname hash
$filerecord->pathnamehash = $this->fs->get_pathname_hash($this->file_record->contextid, $this->file_record->component, $this->file_record->filearea, $this->file_record->itemid, $filepath, $filename);
$this->update($filerecord);
}
/**
* Function stored_file::replace_content_with() is deprecated. Please use stored_file::replace_file_with()
*
* @deprecated since Moodle 2.6 MDL-42016 - please do not use this function any more.
* @see stored_file::replace_file_with()
*/
public function replace_content_with(stored_file $storedfile) {
throw new coding_exception('Function stored_file::replace_content_with() can not be used any more . ' .
'Please use stored_file::replace_file_with()');
}
/**
* Replaces the fields that might have changed when file was overriden in filepicker:
* reference, contenthash, filesize, userid
*
* Note that field 'source' must be updated separately because
* it has different format for draft and non-draft areas and
* this function will usually be used to replace non-draft area
* file with draft area file.
*
* @param stored_file $newfile
* @throws coding_exception
*/
public function replace_file_with(stored_file $newfile) {
if ($newfile->get_referencefileid() &&
$this->fs->get_references_count_by_storedfile($this)) {
// The new file is a reference.
// The current file has other local files referencing to it.
// Double reference is not allowed.
throw new moodle_exception('errordoublereference', 'repository');
}
$filerecord = new stdClass;
if ($this->filesystem->is_file_readable_remotely_by_storedfile($newfile)) {
$contenthash = $newfile->get_contenthash();
$filerecord->contenthash = $contenthash;
} else {
throw new file_exception('storedfileproblem', 'Invalid contenthash, content must be already in filepool', $contenthash);
}
$filerecord->filesize = $newfile->get_filesize();
$filerecord->referencefileid = $newfile->get_referencefileid();
$filerecord->userid = $newfile->get_userid();
$oldcontenthash = $this->get_contenthash();
$this->update($filerecord);
$this->filesystem->remove_file($oldcontenthash);
}
/**
* Unlink the stored file from the referenced file
*
* This methods destroys the link to the record in files_reference table. This effectively
* turns the stored file from being an alias to a plain copy. However, the caller has
* to make sure that the actual file's content has beed synced prior to calling this method.
*/
public function delete_reference() {
global $DB;
if (!$this->is_external_file()) {
throw new coding_exception('An attempt to unlink a non-reference file.');
}
$transaction = $DB->start_delegated_transaction();
// Are we the only one referring to the original file? If so, delete the
// referenced file record. Note we do not use file_storage::search_references_count()
// here because we want to count draft files too and we are at a bit lower access level here.
$countlinks = $DB->count_records('files',
array('referencefileid' => $this->file_record->referencefileid));
if ($countlinks == 1) {
$DB->delete_records('files_reference', array('id' => $this->file_record->referencefileid));
}
// Update the underlying record in the database.
$update = new stdClass();
$update->referencefileid = null;
$this->update($update);
$transaction->allow_commit();
// Update our properties and the record in the memory.
$this->repository = null;
$this->file_record->repositoryid = null;
$this->file_record->reference = null;
$this->file_record->referencefileid = null;
$this->file_record->referencelastsync = null;
}
/**
* Is this a directory?
*
* Directories are only emulated, internally they are stored as empty
* files with a "." instead of name - this means empty directory contains
* exactly one empty file with name dot.
*
* @return bool true means directory, false means file
*/
public function is_directory() {
return ($this->file_record->filename === '.');
}
/**
* Delete file from files table.
*
* The content of files stored in sha1 pool is reclaimed
* later - the occupied disk space is reclaimed much later.
*
* @return bool always true or exception if error occurred
*/
public function delete() {
global $DB;
if ($this->is_directory()) {
// Directories can not be referenced, just delete the record.
$DB->delete_records('files', array('id'=>$this->file_record->id));
} else {
$transaction = $DB->start_delegated_transaction();
// If there are other files referring to this file, convert them to copies.
if ($files = $this->fs->get_references_by_storedfile($this)) {
foreach ($files as $file) {
$this->fs->import_external_file($file);
}
}
// If this file is a reference (alias) to another file, unlink it first.
if ($this->is_external_file()) {
$this->delete_reference();
}
// Now delete the file record.
$DB->delete_records('files', array('id'=>$this->file_record->id));
$transaction->allow_commit();
if (!$this->is_directory()) {
// Callback for file deletion.
if ($pluginsfunction = get_plugins_with_function('after_file_deleted')) {
foreach ($pluginsfunction as $plugintype => $plugins) {
foreach ($plugins as $pluginfunction) {
$pluginfunction($this->file_record);
}
}
}
}
}
// Move pool file to trash if content not needed any more.
$this->filesystem->remove_file($this->file_record->contenthash);
return true; // BC only
}
/**
* adds this file path to a curl request (POST only)
*
* @param curl $curlrequest the curl request object
* @param string $key what key to use in the POST request
* @return void
*/
public function add_to_curl_request(&$curlrequest, $key) {
return $this->filesystem->add_to_curl_request($this, $curlrequest, $key);
}
/**
* Returns file handle - read only mode, no writing allowed into pool files!
*
* When you want to modify a file, create a new file and delete the old one.
*
* @param int $type Type of file handle (FILE_HANDLE_xx constant)
* @return resource file handle
*/
public function get_content_file_handle($type = self::FILE_HANDLE_FOPEN) {
return $this->filesystem->get_content_file_handle($this, $type);
}
/**
* Dumps file content to page.
*/
public function readfile() {
return $this->filesystem->readfile($this);
}
/**
* Returns file content as string.
*
* @return string content
*/
public function get_content() {
return $this->filesystem->get_content($this);
}
/**
* Copy content of file to given pathname.
*
* @param string $pathname real path to the new file
* @return bool success
*/
public function copy_content_to($pathname) {
return $this->filesystem->copy_content_from_storedfile($this, $pathname);
}
/**
* Copy content of file to temporary folder and returns file path
*
* @param string $dir name of the temporary directory
* @param string $fileprefix prefix of temporary file.
* @return string|bool path of temporary file or false.
*/
public function copy_content_to_temp($dir = 'files', $fileprefix = 'tempup_') {
$tempfile = false;
if (!$dir = make_temp_directory($dir)) {
return false;
}
if (!$tempfile = tempnam($dir, $fileprefix)) {
return false;
}
if (!$this->copy_content_to($tempfile)) {
// something went wrong
@unlink($tempfile);
return false;
}
return $tempfile;
}
/**
* List contents of archive.
*
* @param file_packer $packer file packer instance
* @return array of file infos
*/
public function list_files(file_packer $packer) {
return $this->filesystem->list_files($this, $packer);
}
/**
* Extract file to given file path (real OS filesystem), existing files are overwritten.
*
* @param file_packer $packer file packer instance
* @param string $pathname target directory
* @param file_progress $progress Progress indicator callback or null if not required
* @return array|bool list of processed files; false if error
*/
public function extract_to_pathname(file_packer $packer, $pathname,
file_progress $progress = null) {
return $this->filesystem->extract_to_pathname($this, $packer, $pathname, $progress);
}
/**
* Extract file to given file path (real OS filesystem), existing files are overwritten.
*
* @param file_packer $packer file packer instance
* @param int $contextid context ID
* @param string $component component
* @param string $filearea file area
* @param int $itemid item ID
* @param string $pathbase path base
* @param int $userid user ID
* @param file_progress $progress Progress indicator callback or null if not required
* @return array|bool list of processed files; false if error
*/
public function extract_to_storage(file_packer $packer, $contextid,
$component, $filearea, $itemid, $pathbase, $userid = null, file_progress $progress = null) {
return $this->filesystem->extract_to_storage($this, $packer, $contextid, $component, $filearea,
$itemid, $pathbase, $userid, $progress);
}
/**
* Add file/directory into archive.
*
* @param file_archive $filearch file archive instance
* @param string $archivepath pathname in archive
* @return bool success
*/
public function archive_file(file_archive $filearch, $archivepath) {
if ($this->repository) {
$this->sync_external_file();
if ($this->compare_to_string('')) {
// This file is not stored locally - attempt to retrieve it from the repository.
// This may happen if the repository deliberately does not fetch files, or if there is a failure with the sync.
$fileinfo = $this->repository->get_file($this->get_reference());
if (isset($fileinfo['path'])) {
return $filearch->add_file_from_pathname($archivepath, $fileinfo['path']);
}
}
}
return $this->filesystem->add_storedfile_to_archive($this, $filearch, $archivepath);
}
/**
* Returns information about image,
* information is determined from the file content
*
* @return mixed array with width, height and mimetype; false if not an image
*/
public function get_imageinfo() {
return $this->filesystem->get_imageinfo($this);
}
/**
* Verifies the file is a valid web image - gif, png and jpeg only.
*
* It should be ok to serve this image from server without any other security workarounds.
*
* @return bool true if file ok
*/
public function is_valid_image() {
$mimetype = $this->get_mimetype();
if (!file_mimetype_in_typegroup($mimetype, 'web_image')) {
return false;
}
if (!$info = $this->get_imageinfo()) {
return false;
}
if ($info['mimetype'] !== $mimetype) {
return false;
}
// ok, GD likes this image
return true;
}
/**
* Returns parent directory, creates missing parents if needed.
*
* @return stored_file
*/
public function get_parent_directory() {
if ($this->file_record->filepath === '/' and $this->file_record->filename === '.') {
//root dir does not have parent
return null;
}
if ($this->file_record->filename !== '.') {
return $this->fs->create_directory($this->file_record->contextid, $this->file_record->component, $this->file_record->filearea, $this->file_record->itemid, $this->file_record->filepath);
}
$filepath = $this->file_record->filepath;
$filepath = trim($filepath, '/');
$dirs = explode('/', $filepath);
array_pop($dirs);
$filepath = implode('/', $dirs);
$filepath = ($filepath === '') ? '/' : "/$filepath/";
return $this->fs->create_directory($this->file_record->contextid, $this->file_record->component, $this->file_record->filearea, $this->file_record->itemid, $filepath);
}
/**
* Set synchronised content from file.
*
* @param string $path Path to the file.
*/
public function set_synchronised_content_from_file($path) {
$this->fs->synchronise_stored_file_from_file($this, $path, $this->file_record);
}
/**
* Set synchronised content from content.
*
* @param string $content File content.
*/
public function set_synchronised_content_from_string($content) {
$this->fs->synchronise_stored_file_from_string($this, $content, $this->file_record);
}
/**
* Synchronize file if it is a reference and needs synchronizing
*
* Updates contenthash and filesize
*/
public function sync_external_file() {
if (!empty($this->repository)) {
$this->repository->sync_reference($this);
}
}
/**
* Returns context id of the file
*
* @return int context id
*/
public function get_contextid() {
return $this->file_record->contextid;
}
/**
* Returns component name - this is the owner of the areas,
* nothing else is allowed to read or modify the files directly!!
*
* @return string
*/
public function get_component() {
return $this->file_record->component;
}
/**
* Returns file area name, this divides files of one component into groups with different access control.
* All files in one area have the same access control.
*
* @return string
*/
public function get_filearea() {
return $this->file_record->filearea;
}
/**
* Returns returns item id of file.
*
* @return int
*/
public function get_itemid() {
return $this->file_record->itemid;
}
/**
* Returns file path - starts and ends with /, \ are not allowed.
*
* @return string
*/
public function get_filepath() {
return $this->file_record->filepath;
}
/**
* Returns file name or '.' in case of directories.
*
* @return string
*/
public function get_filename() {
return $this->file_record->filename;
}
/**
* Returns id of user who created the file.
*
* @return int
*/
public function get_userid() {
return $this->file_record->userid;
}
/**
* Returns the size of file in bytes.
*
* @return int bytes
*/
public function get_filesize() {
$this->sync_external_file();
return $this->file_record->filesize;
}
/**
* Function stored_file::set_filesize() is deprecated. Please use stored_file::replace_file_with
*
* @deprecated since Moodle 2.6 MDL-42016 - please do not use this function any more.
* @see stored_file::replace_file_with()
*/
public function set_filesize($filesize) {
throw new coding_exception('Function stored_file::set_filesize() can not be used any more. ' .
'Please use stored_file::replace_file_with()');
}
/**
* Returns mime type of file.
*
* @return string
*/
public function get_mimetype() {
return $this->file_record->mimetype;
}
/**
* Returns unix timestamp of file creation date.
*
* @return int
*/
public function get_timecreated() {
return $this->file_record->timecreated;
}
/**
* Returns unix timestamp of last file modification.
*
* @return int
*/
public function get_timemodified() {
$this->sync_external_file();
return $this->file_record->timemodified;
}
/**
* set timemodified
*
* @param int $timemodified
*/
public function set_timemodified($timemodified) {
$filerecord = new stdClass;
$filerecord->timemodified = $timemodified;
$this->update($filerecord);
}
/**
* Returns file status flag.
*
* @return int 0 means file OK, anything else is a problem and file can not be used
*/
public function get_status() {
return $this->file_record->status;
}
/**
* Returns file id.
*
* @return int
*/
public function get_id() {
return $this->file_record->id;
}
/**
* Returns sha1 hash of file content.
*
* @return string
*/
public function get_contenthash() {
$this->sync_external_file();
return $this->file_record->contenthash;
}
/**
* Returns sha1 hash of all file path components sha1("contextid/component/filearea/itemid/dir/dir/filename.ext").
*
* @return string
*/
public function get_pathnamehash() {
return $this->file_record->pathnamehash;
}
/**
* Returns the license type of the file, it is a short name referred from license table.
*
* @return string
*/
public function get_license() {
return $this->file_record->license;
}
/**
* Set license
*
* @param string $license license
*/
public function set_license($license) {
$filerecord = new stdClass;
$filerecord->license = $license;
$this->update($filerecord);
}
/**
* Returns the author name of the file.
*
* @return string
*/
public function get_author() {
return $this->file_record->author;
}
/**
* Set author
*
* @param string $author
*/
public function set_author($author) {
$filerecord = new stdClass;
$filerecord->author = $author;
$this->update($filerecord);
}
/**
* Returns the source of the file, usually it is a url.
*
* @return string
*/
public function get_source() {
return $this->file_record->source;
}
/**
* Set license
*
* @param string $license license
*/
public function set_source($source) {
$filerecord = new stdClass;
$filerecord->source = $source;
$this->update($filerecord);
}
/**
* Returns the sort order of file
*
* @return int
*/
public function get_sortorder() {
return $this->file_record->sortorder;
}
/**
* Set file sort order
*
* @param int $sortorder
* @return int
*/
public function set_sortorder($sortorder) {
$oldorder = $this->file_record->sortorder;
$filerecord = new stdClass;
$filerecord->sortorder = $sortorder;
$this->update($filerecord);
if (!$this->is_directory()) {
// Callback for file sort order change.
if ($pluginsfunction = get_plugins_with_function('after_file_sorted')) {
foreach ($pluginsfunction as $plugintype => $plugins) {
foreach ($plugins as $pluginfunction) {
$pluginfunction($this->file_record, $oldorder, $sortorder);
}
}
}
}
}
/**
* Returns repository id
*
* @return int|null
*/
public function get_repository_id() {
if (!empty($this->repository)) {
return $this->repository->id;
} else {
return null;
}
}
/**
* Returns repository type.
*
* @return mixed str|null the repository type or null if is not an external file
* @since Moodle 3.3
*/
public function get_repository_type() {
if (!empty($this->repository)) {
return $this->repository->get_typename();
} else {
return null;
}
}
/**
* get reference file id
* @return int
*/
public function get_referencefileid() {
return $this->file_record->referencefileid;
}
/**
* Get reference last sync time
* @return int
*/
public function get_referencelastsync() {
return $this->file_record->referencelastsync;
}
/**
* Function stored_file::get_referencelifetime() is deprecated as reference
* life time is no longer stored in DB or returned by repository. Each
* repository should decide by itself when to synchronise the references.
*
* @deprecated since Moodle 2.6 MDL-42016 - please do not use this function any more.
* @see repository::sync_reference()
*/
public function get_referencelifetime() {
throw new coding_exception('Function stored_file::get_referencelifetime() can not be used any more. ' .
'See repository::sync_reference().');
}
/**
* Returns file reference
*
* @return string
*/
public function get_reference() {
return $this->file_record->reference;
}
/**
* Get human readable file reference information
*
* @return string
*/
public function get_reference_details() {
return $this->repository->get_reference_details($this->get_reference(), $this->get_status());
}
/**
* Called after reference-file has been synchronized with the repository
*
* We update contenthash, filesize and status in files table if changed
* and we always update lastsync in files_reference table
*
* @param null|string $contenthash if set to null contenthash is not changed
* @param int $filesize new size of the file
* @param int $status new status of the file (0 means OK, 666 - source missing)
* @param int $timemodified last time modified of the source, if known
*/
public function set_synchronized($contenthash, $filesize, $status = 0, $timemodified = null) {
if (!$this->is_external_file()) {
return;
}
$now = time();
if ($contenthash === null) {
$contenthash = $this->file_record->contenthash;
}
if ($contenthash != $this->file_record->contenthash) {
$oldcontenthash = $this->file_record->contenthash;
}
// this will update all entries in {files} that have the same filereference id
$this->fs->update_references($this->file_record->referencefileid, $now, null, $contenthash, $filesize, $status, $timemodified);
// we don't need to call update() for this object, just set the values of changed fields
$this->file_record->contenthash = $contenthash;
$this->file_record->filesize = $filesize;
$this->file_record->status = $status;
$this->file_record->referencelastsync = $now;
if ($timemodified) {
$this->file_record->timemodified = $timemodified;
}
if (isset($oldcontenthash)) {
$this->filesystem->remove_file($oldcontenthash);
}
}
/**
* Sets the error status for a file that could not be synchronised
*/
public function set_missingsource() {
$this->set_synchronized($this->file_record->contenthash, $this->file_record->filesize, 666);
}
/**
* Send file references
*
* @param int $lifetime Number of seconds before the file should expire from caches (default 24 hours)
* @param int $filter 0 (default)=no filtering, 1=all files, 2=html files only
* @param bool $forcedownload If true (default false), forces download of file rather than view in browser/plugin
* @param array $options additional options affecting the file serving
*/
public function send_file($lifetime, $filter, $forcedownload, $options) {
$this->repository->send_file($this, $lifetime, $filter, $forcedownload, $options);
}
/**
* Imports the contents of an external file into moodle filepool.
*
* @throws moodle_exception if file could not be downloaded or is too big
* @param int $maxbytes throw an exception if file size is bigger than $maxbytes (0 means no limit)
*/
public function import_external_file_contents($maxbytes = 0) {
if ($this->repository) {
$this->repository->import_external_file_contents($this, $maxbytes);
}
}
/**
* Gets a file relative to this file in the repository and sends it to the browser.
* Checks the function repository::supports_relative_file() to make sure it can be used.
*
* @param string $relativepath the relative path to the file we are trying to access
*/
public function send_relative_file($relativepath) {
if ($this->repository && $this->repository->supports_relative_file()) {
$relativepath = clean_param($relativepath, PARAM_PATH);
$this->repository->send_relative_file($this, $relativepath);
} else {
send_file_not_found();
}
}
/**
* Generates a thumbnail for this stored_file.
*
* If the GD library has at least version 2 and PNG support is available, the returned data
* is the content of a transparent PNG file containing the thumbnail. Otherwise, the function
* returns contents of a JPEG file with black background containing the thumbnail.
*
* @param int $width the width of the requested thumbnail
* @param int $height the height of the requested thumbnail
* @return string|bool false if a problem occurs, the thumbnail image data otherwise
*/
public function generate_image_thumbnail($width, $height) {
global $CFG;
require_once($CFG->libdir . '/gdlib.php');
if (empty($width) or empty($height)) {
return false;
}
$content = $this->get_content();
// Fetch the image information for this image.
$imageinfo = @getimagesizefromstring($content);
if (empty($imageinfo)) {
return false;
}
// Create a new image from the file.
$original = @imagecreatefromstring($content);
// Generate the thumbnail.
return generate_image_thumbnail_from_image($original, $imageinfo, $width, $height);
}
/**
* Generate a resized image for this stored_file.
*
* @param int|null $width The desired width, or null to only use the height.
* @param int|null $height The desired height, or null to only use the width.
* @return string|false False when a problem occurs, else the image data.
*/
public function resize_image($width, $height) {
global $CFG;
require_once($CFG->libdir . '/gdlib.php');
$content = $this->get_content();
// Fetch the image information for this image.
$imageinfo = @getimagesizefromstring($content);
if (empty($imageinfo)) {
return false;
}
// Create a new image from the file.
$original = @imagecreatefromstring($content);
// Generate the resized image.
return resize_image_from_image($original, $imageinfo, $width, $height);
}
/**
* Check whether the supplied file is the same as this file.
*
* @param string $path The path to the file on disk
* @return boolean
*/
public function compare_to_path($path) {
return $this->get_contenthash() === file_storage::hash_from_path($path);
}
/**
* Check whether the supplied content is the same as this file.
*
* @param string $content The file content
* @return boolean
*/
public function compare_to_string($content) {
return $this->get_contenthash() === file_storage::hash_from_string($content);
}
/**
* Generate a rotated image for this stored_file based on exif information.
*
* @return array|false False when a problem occurs, else the image data and image size.
* @since Moodle 3.8
*/
public function rotate_image() {
$content = $this->get_content();
$mimetype = $this->get_mimetype();
if ($mimetype === "image/jpeg" && function_exists("exif_read_data")) {
$exif = @exif_read_data("data://image/jpeg;base64," . base64_encode($content));
if (isset($exif['ExifImageWidth']) && isset($exif['ExifImageLength']) && isset($exif['Orientation'])) {
$rotation = [
3 => -180,
6 => -90,
8 => -270,
];
$orientation = $exif['Orientation'];
if ($orientation !== 1) {
$source = @imagecreatefromstring($content);
$data = @imagerotate($source, $rotation[$orientation], 0);
if (!empty($data)) {
if ($orientation == 1 || $orientation == 3) {
$size = [
'width' => $exif["ExifImageWidth"],
'height' => $exif["ExifImageLength"],
];
} else {
$size = [
'height' => $exif["ExifImageWidth"],
'width' => $exif["ExifImageLength"],
];
}
imagedestroy($source);
return [$data, $size];
}
}
}
}
return [false, false];
}
}