Merge branch 'wip-MDL-42016-master' of git://github.com/marinaglancy/moodle
[moodle.git] / lib / filestorage / stored_file.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * Definition of a class stored_file.
20  *
21  * @package   core_files
22  * @copyright 2008 Petr Skoda {@link http://skodak.org}
23  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 defined('MOODLE_INTERNAL') || die();
28 require_once($CFG->dirroot . '/lib/filestorage/file_progress.php');
30 /**
31  * Class representing local files stored in a sha1 file pool.
32  *
33  * Since Moodle 2.0 file contents are stored in sha1 pool and
34  * all other file information is stored in new "files" database table.
35  *
36  * @package   core_files
37  * @category  files
38  * @copyright 2008 Petr Skoda {@link http://skodak.org}
39  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
40  * @since     Moodle 2.0
41  */
42 class stored_file {
43     /** @var file_storage file storage pool instance */
44     private $fs;
45     /** @var stdClass record from the files table left join files_reference table */
46     private $file_record;
47     /** @var string location of content files */
48     private $filedir;
49     /** @var repository repository plugin instance */
50     private $repository;
52     /**
53      * Constructor, this constructor should be called ONLY from the file_storage class!
54      *
55      * @param file_storage $fs file  storage instance
56      * @param stdClass $file_record description of file
57      * @param string $filedir location of file directory with sh1 named content files
58      */
59     public function __construct(file_storage $fs, stdClass $file_record, $filedir) {
60         global $DB, $CFG;
61         $this->fs          = $fs;
62         $this->file_record = clone($file_record); // prevent modifications
63         $this->filedir     = $filedir; // keep secret, do not expose!
65         if (!empty($file_record->repositoryid)) {
66             require_once("$CFG->dirroot/repository/lib.php");
67             $this->repository = repository::get_repository_by_id($file_record->repositoryid, SYSCONTEXTID);
68             if ($this->repository->supported_returntypes() & FILE_REFERENCE != FILE_REFERENCE) {
69                 // Repository cannot do file reference.
70                 throw new moodle_exception('error');
71             }
72         } else {
73             $this->repository = null;
74         }
75         // make sure all reference fields exist in file_record even when it is not a reference
76         foreach (array('referencelastsync', 'referencefileid', 'reference', 'repositoryid') as $key) {
77             if (empty($this->file_record->$key)) {
78                 $this->file_record->$key = null;
79             }
80         }
81     }
83     /**
84      * Whether or not this is a external resource
85      *
86      * @return bool
87      */
88     public function is_external_file() {
89         return !empty($this->repository);
90     }
92     /**
93      * Update some file record fields
94      * NOTE: Must remain protected
95      *
96      * @param stdClass $dataobject
97      */
98     protected function update($dataobject) {
99         global $DB;
100         $updatereferencesneeded = false;
101         $keys = array_keys((array)$this->file_record);
102         foreach ($dataobject as $field => $value) {
103             if (in_array($field, $keys)) {
104                 if ($field == 'contextid' and (!is_number($value) or $value < 1)) {
105                     throw new file_exception('storedfileproblem', 'Invalid contextid');
106                 }
108                 if ($field == 'component') {
109                     $value = clean_param($value, PARAM_COMPONENT);
110                     if (empty($value)) {
111                         throw new file_exception('storedfileproblem', 'Invalid component');
112                     }
113                 }
115                 if ($field == 'filearea') {
116                     $value = clean_param($value, PARAM_AREA);
117                     if (empty($value)) {
118                         throw new file_exception('storedfileproblem', 'Invalid filearea');
119                     }
120                 }
122                 if ($field == 'itemid' and (!is_number($value) or $value < 0)) {
123                     throw new file_exception('storedfileproblem', 'Invalid itemid');
124                 }
127                 if ($field == 'filepath') {
128                     $value = clean_param($value, PARAM_PATH);
129                     if (strpos($value, '/') !== 0 or strrpos($value, '/') !== strlen($value)-1) {
130                         // path must start and end with '/'
131                         throw new file_exception('storedfileproblem', 'Invalid file path');
132                     }
133                 }
135                 if ($field == 'filename') {
136                     // folder has filename == '.', so we pass this
137                     if ($value != '.') {
138                         $value = clean_param($value, PARAM_FILE);
139                     }
140                     if ($value === '') {
141                         throw new file_exception('storedfileproblem', 'Invalid file name');
142                     }
143                 }
145                 if ($field === 'timecreated' or $field === 'timemodified') {
146                     if (!is_number($value)) {
147                         throw new file_exception('storedfileproblem', 'Invalid timestamp');
148                     }
149                     if ($value < 0) {
150                         $value = 0;
151                     }
152                 }
154                 if ($field === 'referencefileid') {
155                     if (!is_null($value) and !is_number($value)) {
156                         throw new file_exception('storedfileproblem', 'Invalid reference info');
157                     }
158                 }
160                 if (($field == 'contenthash' || $field == 'filesize') && $this->file_record->$field != $value) {
161                     $updatereferencesneeded = true;
162                 }
164                 // adding the field
165                 $this->file_record->$field = $value;
166             } else {
167                 throw new coding_exception("Invalid field name, $field doesn't exist in file record");
168             }
169         }
170         // Validate mimetype field
171         // we don't use {@link stored_file::get_content_file_location()} here becaues it will try to update file_record
172         $pathname = $this->get_pathname_by_contenthash();
173         // try to recover the content from trash
174         if (!is_readable($pathname)) {
175             if (!$this->fs->try_content_recovery($this) or !is_readable($pathname)) {
176                 throw new file_exception('storedfilecannotread', '', $pathname);
177             }
178         }
179         $mimetype = $this->fs->mimetype($pathname, $this->file_record->filename);
180         $this->file_record->mimetype = $mimetype;
182         $DB->update_record('files', $this->file_record);
183         if ($updatereferencesneeded) {
184             // Either filesize or contenthash of this file have changed. Update all files that reference to it.
185             $this->fs->update_references_to_storedfile($this);
186         }
187     }
189     /**
190      * Rename filename
191      *
192      * @param string $filepath file path
193      * @param string $filename file name
194      */
195     public function rename($filepath, $filename) {
196         if ($this->fs->file_exists($this->get_contextid(), $this->get_component(), $this->get_filearea(), $this->get_itemid(), $filepath, $filename)) {
197             throw new file_exception('storedfilenotcreated', '', 'file exists, cannot rename');
198         }
199         $filerecord = new stdClass;
200         $filerecord->filepath = $filepath;
201         $filerecord->filename = $filename;
202         // populate the pathname hash
203         $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);
204         $this->update($filerecord);
205     }
207     /**
208      * Replace the content by providing another stored_file instance
209      *
210      * @deprecated since 2.6
211      * @see stored_file::replace_file_with()
212      * @param stored_file $storedfile
213      */
214     public function replace_content_with(stored_file $storedfile) {
215         debugging('Function stored_file::replace_content_with() is deprecated. Please use stored_file::replace_file_with()', DEBUG_DEVELOPER);
216         $filerecord = new stdClass;
217         $contenthash = $storedfile->get_contenthash();
218         if ($this->fs->content_exists($contenthash)) {
219             $filerecord->contenthash = $contenthash;
220         } else {
221             throw new file_exception('storedfileproblem', 'Invalid contenthash, content must be already in filepool', $contenthash);
222         }
223         $filerecord->filesize = $storedfile->get_filesize();
224         $this->update($filerecord);
225     }
227     /**
228      * Replaces the fields that might have changed when file was overriden in filepicker:
229      * reference, contenthash, filesize, userid
230      *
231      * Note that field 'source' must be updated separately because
232      * it has different format for draft and non-draft areas and
233      * this function will usually be used to replace non-draft area
234      * file with draft area file.
235      *
236      * @param stored_file $newfile
237      * @throws coding_exception
238      */
239     public function replace_file_with(stored_file $newfile) {
240         if ($newfile->get_referencefileid() &&
241                 $this->fs->get_references_count_by_storedfile($this)) {
242             // The new file is a reference.
243             // The current file has other local files referencing to it.
244             // Double reference is not allowed.
245             throw new moodle_exception('errordoublereference', 'repository');
246         }
248         $filerecord = new stdClass;
249         $contenthash = $newfile->get_contenthash();
250         if ($this->fs->content_exists($contenthash)) {
251             $filerecord->contenthash = $contenthash;
252         } else {
253             throw new file_exception('storedfileproblem', 'Invalid contenthash, content must be already in filepool', $contenthash);
254         }
255         $filerecord->filesize = $newfile->get_filesize();
256         $filerecord->referencefileid = $newfile->get_referencefileid();
257         $filerecord->userid = $newfile->get_userid();
258         $this->update($filerecord);
259     }
261     /**
262      * Unlink the stored file from the referenced file
263      *
264      * This methods destroys the link to the record in files_reference table. This effectively
265      * turns the stored file from being an alias to a plain copy. However, the caller has
266      * to make sure that the actual file's content has beed synced prior to calling this method.
267      */
268     public function delete_reference() {
269         global $DB;
271         if (!$this->is_external_file()) {
272             throw new coding_exception('An attempt to unlink a non-reference file.');
273         }
275         $transaction = $DB->start_delegated_transaction();
277         // Are we the only one referring to the original file? If so, delete the
278         // referenced file record. Note we do not use file_storage::search_references_count()
279         // here because we want to count draft files too and we are at a bit lower access level here.
280         $countlinks = $DB->count_records('files',
281             array('referencefileid' => $this->file_record->referencefileid));
282         if ($countlinks == 1) {
283             $DB->delete_records('files_reference', array('id' => $this->file_record->referencefileid));
284         }
286         // Update the underlying record in the database.
287         $update = new stdClass();
288         $update->referencefileid = null;
289         $this->update($update);
291         $transaction->allow_commit();
293         // Update our properties and the record in the memory.
294         $this->repository = null;
295         $this->file_record->repositoryid = null;
296         $this->file_record->reference = null;
297         $this->file_record->referencefileid = null;
298         $this->file_record->referencelastsync = null;
299     }
301     /**
302      * Is this a directory?
303      *
304      * Directories are only emulated, internally they are stored as empty
305      * files with a "." instead of name - this means empty directory contains
306      * exactly one empty file with name dot.
307      *
308      * @return bool true means directory, false means file
309      */
310     public function is_directory() {
311         return ($this->file_record->filename === '.');
312     }
314     /**
315      * Delete file from files table.
316      *
317      * The content of files stored in sha1 pool is reclaimed
318      * later - the occupied disk space is reclaimed much later.
319      *
320      * @return bool always true or exception if error occurred
321      */
322     public function delete() {
323         global $DB;
325         if ($this->is_directory()) {
326             // Directories can not be referenced, just delete the record.
327             $DB->delete_records('files', array('id'=>$this->file_record->id));
329         } else {
330             $transaction = $DB->start_delegated_transaction();
332             // If there are other files referring to this file, convert them to copies.
333             if ($files = $this->fs->get_references_by_storedfile($this)) {
334                 foreach ($files as $file) {
335                     $this->fs->import_external_file($file);
336                 }
337             }
339             // If this file is a reference (alias) to another file, unlink it first.
340             if ($this->is_external_file()) {
341                 $this->delete_reference();
342             }
344             // Now delete the file record.
345             $DB->delete_records('files', array('id'=>$this->file_record->id));
347             $transaction->allow_commit();
348         }
350         // Move pool file to trash if content not needed any more.
351         $this->fs->deleted_file_cleanup($this->file_record->contenthash);
352         return true; // BC only
353     }
355     /**
356      * Get file pathname by contenthash
357      *
358      * NOTE, this function is not calling sync_external_file, it assume the contenthash is current
359      * Protected - developers must not gain direct access to this function.
360      *
361      * @return string full path to pool file with file content
362      */
363     protected function get_pathname_by_contenthash() {
364         // Detect is local file or not.
365         $contenthash = $this->file_record->contenthash;
366         $l1 = $contenthash[0].$contenthash[1];
367         $l2 = $contenthash[2].$contenthash[3];
368         return "$this->filedir/$l1/$l2/$contenthash";
369     }
371     /**
372      * Get file pathname by given contenthash, this method will try to sync files
373      *
374      * Protected - developers must not gain direct access to this function.
375      *
376      * NOTE: do not make this public, we must not modify or delete the pool files directly! ;-)
377      *
378      * @return string full path to pool file with file content
379      **/
380     protected function get_content_file_location() {
381         $this->sync_external_file();
382         return $this->get_pathname_by_contenthash();
383     }
385     /**
386     * adds this file path to a curl request (POST only)
387     *
388     * @param curl $curlrequest the curl request object
389     * @param string $key what key to use in the POST request
390     * @return void
391     */
392     public function add_to_curl_request(&$curlrequest, $key) {
393         $curlrequest->_tmp_file_post_params[$key] = '@' . $this->get_content_file_location();
394     }
396     /**
397      * Returns file handle - read only mode, no writing allowed into pool files!
398      *
399      * When you want to modify a file, create a new file and delete the old one.
400      *
401      * @return resource file handle
402      */
403     public function get_content_file_handle() {
404         $path = $this->get_content_file_location();
405         if (!is_readable($path)) {
406             if (!$this->fs->try_content_recovery($this) or !is_readable($path)) {
407                 throw new file_exception('storedfilecannotread', '', $path);
408             }
409         }
410         return fopen($path, 'rb'); // Binary reading only!!
411     }
413     /**
414      * Dumps file content to page.
415      */
416     public function readfile() {
417         $path = $this->get_content_file_location();
418         if (!is_readable($path)) {
419             if (!$this->fs->try_content_recovery($this) or !is_readable($path)) {
420                 throw new file_exception('storedfilecannotread', '', $path);
421             }
422         }
423         readfile_allow_large($path, $this->get_filesize());
424     }
426     /**
427      * Returns file content as string.
428      *
429      * @return string content
430      */
431     public function get_content() {
432         $path = $this->get_content_file_location();
433         if (!is_readable($path)) {
434             if (!$this->fs->try_content_recovery($this) or !is_readable($path)) {
435                 throw new file_exception('storedfilecannotread', '', $path);
436             }
437         }
438         return file_get_contents($this->get_content_file_location());
439     }
441     /**
442      * Copy content of file to given pathname.
443      *
444      * @param string $pathname real path to the new file
445      * @return bool success
446      */
447     public function copy_content_to($pathname) {
448         $path = $this->get_content_file_location();
449         if (!is_readable($path)) {
450             if (!$this->fs->try_content_recovery($this) or !is_readable($path)) {
451                 throw new file_exception('storedfilecannotread', '', $path);
452             }
453         }
454         return copy($path, $pathname);
455     }
457     /**
458      * Copy content of file to temporary folder and returns file path
459      *
460      * @param string $dir name of the temporary directory
461      * @param string $fileprefix prefix of temporary file.
462      * @return string|bool path of temporary file or false.
463      */
464     public function copy_content_to_temp($dir = 'files', $fileprefix = 'tempup_') {
465         $tempfile = false;
466         if (!$dir = make_temp_directory($dir)) {
467             return false;
468         }
469         if (!$tempfile = tempnam($dir, $fileprefix)) {
470             return false;
471         }
472         if (!$this->copy_content_to($tempfile)) {
473             // something went wrong
474             @unlink($tempfile);
475             return false;
476         }
477         return $tempfile;
478     }
480     /**
481      * List contents of archive.
482      *
483      * @param file_packer $packer file packer instance
484      * @return array of file infos
485      */
486     public function list_files(file_packer $packer) {
487         $archivefile = $this->get_content_file_location();
488         return $packer->list_files($archivefile);
489     }
491     /**
492      * Extract file to given file path (real OS filesystem), existing files are overwritten.
493      *
494      * @param file_packer $packer file packer instance
495      * @param string $pathname target directory
496      * @param file_progress $progress Progress indicator callback or null if not required
497      * @return array|bool list of processed files; false if error
498      */
499     public function extract_to_pathname(file_packer $packer, $pathname,
500             file_progress $progress = null) {
501         $archivefile = $this->get_content_file_location();
502         return $packer->extract_to_pathname($archivefile, $pathname, null, $progress);
503     }
505     /**
506      * Extract file to given file path (real OS filesystem), existing files are overwritten.
507      *
508      * @param file_packer $packer file packer instance
509      * @param int $contextid context ID
510      * @param string $component component
511      * @param string $filearea file area
512      * @param int $itemid item ID
513      * @param string $pathbase path base
514      * @param int $userid user ID
515      * @param file_progress $progress Progress indicator callback or null if not required
516      * @return array|bool list of processed files; false if error
517      */
518     public function extract_to_storage(file_packer $packer, $contextid,
519             $component, $filearea, $itemid, $pathbase, $userid = null, file_progress $progress = null) {
520         $archivefile = $this->get_content_file_location();
521         return $packer->extract_to_storage($archivefile, $contextid,
522                 $component, $filearea, $itemid, $pathbase, $userid, $progress);
523     }
525     /**
526      * Add file/directory into archive.
527      *
528      * @param file_archive $filearch file archive instance
529      * @param string $archivepath pathname in archive
530      * @return bool success
531      */
532     public function archive_file(file_archive $filearch, $archivepath) {
533         if ($this->is_directory()) {
534             return $filearch->add_directory($archivepath);
535         } else {
536             $path = $this->get_content_file_location();
537             if (!is_readable($path)) {
538                 return false;
539             }
540             return $filearch->add_file_from_pathname($archivepath, $path);
541         }
542     }
544     /**
545      * Returns information about image,
546      * information is determined from the file content
547      *
548      * @return mixed array with width, height and mimetype; false if not an image
549      */
550     public function get_imageinfo() {
551         $path = $this->get_content_file_location();
552         if (!is_readable($path)) {
553             if (!$this->fs->try_content_recovery($this) or !is_readable($path)) {
554                 throw new file_exception('storedfilecannotread', '', $path);
555             }
556         }
557         $mimetype = $this->get_mimetype();
558         if (!preg_match('|^image/|', $mimetype) || !filesize($path) || !($imageinfo = getimagesize($path))) {
559             return false;
560         }
561         $image = array('width'=>$imageinfo[0], 'height'=>$imageinfo[1], 'mimetype'=>image_type_to_mime_type($imageinfo[2]));
562         if (empty($image['width']) or empty($image['height']) or empty($image['mimetype'])) {
563             // gd can not parse it, sorry
564             return false;
565         }
566         return $image;
567     }
569     /**
570      * Verifies the file is a valid web image - gif, png and jpeg only.
571      *
572      * It should be ok to serve this image from server without any other security workarounds.
573      *
574      * @return bool true if file ok
575      */
576     public function is_valid_image() {
577         $mimetype = $this->get_mimetype();
578         if (!file_mimetype_in_typegroup($mimetype, 'web_image')) {
579             return false;
580         }
581         if (!$info = $this->get_imageinfo()) {
582             return false;
583         }
584         if ($info['mimetype'] !== $mimetype) {
585             return false;
586         }
587         // ok, GD likes this image
588         return true;
589     }
591     /**
592      * Returns parent directory, creates missing parents if needed.
593      *
594      * @return stored_file
595      */
596     public function get_parent_directory() {
597         if ($this->file_record->filepath === '/' and $this->file_record->filename === '.') {
598             //root dir does not have parent
599             return null;
600         }
602         if ($this->file_record->filename !== '.') {
603             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);
604         }
606         $filepath = $this->file_record->filepath;
607         $filepath = trim($filepath, '/');
608         $dirs = explode('/', $filepath);
609         array_pop($dirs);
610         $filepath = implode('/', $dirs);
611         $filepath = ($filepath === '') ? '/' : "/$filepath/";
613         return $this->fs->create_directory($this->file_record->contextid, $this->file_record->component, $this->file_record->filearea, $this->file_record->itemid, $filepath);
614     }
616     /**
617      * Synchronize file if it is a reference and needs synchronizing
618      *
619      * Updates contenthash and filesize
620      */
621     public function sync_external_file() {
622         if (!empty($this->repository)) {
623             $this->repository->sync_reference($this);
624         }
625     }
627     /**
628      * Returns context id of the file
629      *
630      * @return int context id
631      */
632     public function get_contextid() {
633         return $this->file_record->contextid;
634     }
636     /**
637      * Returns component name - this is the owner of the areas,
638      * nothing else is allowed to read or modify the files directly!!
639      *
640      * @return string
641      */
642     public function get_component() {
643         return $this->file_record->component;
644     }
646     /**
647      * Returns file area name, this divides files of one component into groups with different access control.
648      * All files in one area have the same access control.
649      *
650      * @return string
651      */
652     public function get_filearea() {
653         return $this->file_record->filearea;
654     }
656     /**
657      * Returns returns item id of file.
658      *
659      * @return int
660      */
661     public function get_itemid() {
662         return $this->file_record->itemid;
663     }
665     /**
666      * Returns file path - starts and ends with /, \ are not allowed.
667      *
668      * @return string
669      */
670     public function get_filepath() {
671         return $this->file_record->filepath;
672     }
674     /**
675      * Returns file name or '.' in case of directories.
676      *
677      * @return string
678      */
679     public function get_filename() {
680         return $this->file_record->filename;
681     }
683     /**
684      * Returns id of user who created the file.
685      *
686      * @return int
687      */
688     public function get_userid() {
689         return $this->file_record->userid;
690     }
692     /**
693      * Returns the size of file in bytes.
694      *
695      * @return int bytes
696      */
697     public function get_filesize() {
698         $this->sync_external_file();
699         return $this->file_record->filesize;
700     }
702      /**
703      * Returns the size of file in bytes.
704      *
705      * @param int $filesize bytes
706      */
707     public function set_filesize($filesize) {
708         debugging('Function stored_file::set_filesize() is deprecated. Please use stored_file::replace_file_with()', DEBUG_DEVELOPER);
709         $filerecord = new stdClass;
710         $filerecord->filesize = $filesize;
711         $this->update($filerecord);
712     }
714     /**
715      * Returns mime type of file.
716      *
717      * @return string
718      */
719     public function get_mimetype() {
720         return $this->file_record->mimetype;
721     }
723     /**
724      * Returns unix timestamp of file creation date.
725      *
726      * @return int
727      */
728     public function get_timecreated() {
729         return $this->file_record->timecreated;
730     }
732     /**
733      * Returns unix timestamp of last file modification.
734      *
735      * @return int
736      */
737     public function get_timemodified() {
738         $this->sync_external_file();
739         return $this->file_record->timemodified;
740     }
742     /**
743      * set timemodified
744      *
745      * @param int $timemodified
746      */
747     public function set_timemodified($timemodified) {
748         $filerecord = new stdClass;
749         $filerecord->timemodified = $timemodified;
750         $this->update($filerecord);
751     }
753     /**
754      * Returns file status flag.
755      *
756      * @return int 0 means file OK, anything else is a problem and file can not be used
757      */
758     public function get_status() {
759         return $this->file_record->status;
760     }
762     /**
763      * Returns file id.
764      *
765      * @return int
766      */
767     public function get_id() {
768         return $this->file_record->id;
769     }
771     /**
772      * Returns sha1 hash of file content.
773      *
774      * @return string
775      */
776     public function get_contenthash() {
777         $this->sync_external_file();
778         return $this->file_record->contenthash;
779     }
781     /**
782      * Returns sha1 hash of all file path components sha1("contextid/component/filearea/itemid/dir/dir/filename.ext").
783      *
784      * @return string
785      */
786     public function get_pathnamehash() {
787         return $this->file_record->pathnamehash;
788     }
790     /**
791      * Returns the license type of the file, it is a short name referred from license table.
792      *
793      * @return string
794      */
795     public function get_license() {
796         return $this->file_record->license;
797     }
799     /**
800      * Set license
801      *
802      * @param string $license license
803      */
804     public function set_license($license) {
805         $filerecord = new stdClass;
806         $filerecord->license = $license;
807         $this->update($filerecord);
808     }
810     /**
811      * Returns the author name of the file.
812      *
813      * @return string
814      */
815     public function get_author() {
816         return $this->file_record->author;
817     }
819     /**
820      * Set author
821      *
822      * @param string $author
823      */
824     public function set_author($author) {
825         $filerecord = new stdClass;
826         $filerecord->author = $author;
827         $this->update($filerecord);
828     }
830     /**
831      * Returns the source of the file, usually it is a url.
832      *
833      * @return string
834      */
835     public function get_source() {
836         return $this->file_record->source;
837     }
839     /**
840      * Set license
841      *
842      * @param string $license license
843      */
844     public function set_source($source) {
845         $filerecord = new stdClass;
846         $filerecord->source = $source;
847         $this->update($filerecord);
848     }
851     /**
852      * Returns the sort order of file
853      *
854      * @return int
855      */
856     public function get_sortorder() {
857         return $this->file_record->sortorder;
858     }
860     /**
861      * Set file sort order
862      *
863      * @param int $sortorder
864      * @return int
865      */
866     public function set_sortorder($sortorder) {
867         $filerecord = new stdClass;
868         $filerecord->sortorder = $sortorder;
869         $this->update($filerecord);
870     }
872     /**
873      * Returns repository id
874      *
875      * @return int|null
876      */
877     public function get_repository_id() {
878         if (!empty($this->repository)) {
879             return $this->repository->id;
880         } else {
881             return null;
882         }
883     }
885     /**
886      * get reference file id
887      * @return int
888      */
889     public function get_referencefileid() {
890         return $this->file_record->referencefileid;
891     }
893     /**
894      * Get reference last sync time
895      * @return int
896      */
897     public function get_referencelastsync() {
898         return $this->file_record->referencelastsync;
899     }
901     /**
902      * Get reference life time (in seconds) after which sync is required
903      *
904      * This data is no longer stored in DB or returned by repository. Each
905      * repository should decide by itself when to synchronise the references.
906      *
907      * @deprecated since 2.6
908      * @see repository::sync_reference()
909      * @return int
910      */
911     public function get_referencelifetime() {
912         debugging('Function stored_file::get_referencelifetime() is deprecated.', DEBUG_DEVELOPER);
913         if ($this->repository) {
914             if (method_exists($this->repository, 'get_reference_file_lifetime')) {
915                 return $this->repository->get_reference_file_lifetime($this->get_reference());
916             } else {
917                 return 24 * 60 * 60;
918             }
919         } else {
920             return 0;
921         }
922     }
923     /**
924      * Returns file reference
925      *
926      * @return string
927      */
928     public function get_reference() {
929         return $this->file_record->reference;
930     }
932     /**
933      * Get human readable file reference information
934      *
935      * @return string
936      */
937     public function get_reference_details() {
938         return $this->repository->get_reference_details($this->get_reference(), $this->get_status());
939     }
941     /**
942      * Called after reference-file has been synchronized with the repository
943      *
944      * We update contenthash, filesize and status in files table if changed
945      * and we always update lastsync in files_reference table
946      *
947      * @param null|string $contenthash if set to null contenthash is not changed
948      * @param int $filesize new size of the file
949      * @param int $status new status of the file (0 means OK, 666 - source missing)
950      */
951     public function set_synchronized($contenthash, $filesize, $status = 0) {
952         if (!$this->is_external_file()) {
953             return;
954         }
955         $now = time();
956         if ($contenthash === null) {
957             $contenthash = $this->file_record->contenthash;
958         }
959         if ($contenthash != $this->file_record->contenthash) {
960             $oldcontenthash = $this->file_record->contenthash;
961         }
962         // this will update all entries in {files} that have the same filereference id
963         $this->fs->update_references($this->file_record->referencefileid, $now, null, $contenthash, $filesize, $status);
964         // we don't need to call update() for this object, just set the values of changed fields
965         $this->file_record->contenthash = $contenthash;
966         $this->file_record->filesize = $filesize;
967         $this->file_record->status = $status;
968         $this->file_record->referencelastsync = $now;
969         if (isset($oldcontenthash)) {
970             $this->fs->deleted_file_cleanup($oldcontenthash);
971         }
972     }
974     /**
975      * Sets the error status for a file that could not be synchronised
976      */
977     public function set_missingsource() {
978         $this->set_synchronized($this->file_record->contenthash, $this->file_record->filesize, 666);
979     }
981     /**
982      * Send file references
983      *
984      * @param int $lifetime Number of seconds before the file should expire from caches (default 24 hours)
985      * @param int $filter 0 (default)=no filtering, 1=all files, 2=html files only
986      * @param bool $forcedownload If true (default false), forces download of file rather than view in browser/plugin
987      * @param array $options additional options affecting the file serving
988      */
989     public function send_file($lifetime, $filter, $forcedownload, $options) {
990         $this->repository->send_file($this, $lifetime, $filter, $forcedownload, $options);
991     }
993     /**
994      * Imports the contents of an external file into moodle filepool.
995      *
996      * @throws moodle_exception if file could not be downloaded or is too big
997      * @param int $maxbytes throw an exception if file size is bigger than $maxbytes (0 means no limit)
998      */
999     public function import_external_file_contents($maxbytes = 0) {
1000         if ($this->repository) {
1001             $this->repository->import_external_file_contents($this, $maxbytes);
1002         }
1003     }
1005     /**
1006      * Gets a file relative to this file in the repository and sends it to the browser.
1007      * Checks the function repository::supports_relative_file() to make sure it can be used.
1008      *
1009      * @param string $relativepath the relative path to the file we are trying to access
1010      */
1011     public function send_relative_file($relativepath) {
1012         if ($this->repository && $this->repository->supports_relative_file()) {
1013             $relativepath = clean_param($relativepath, PARAM_PATH);
1014             $this->repository->send_relative_file($this, $relativepath);
1015         } else {
1016             send_file_not_found();
1017         }
1018     }