7afca6c60fe945104e7e0b91a4202e2750263bd7
[moodle.git] / lib / filebrowser / file_info_context_course.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  * Utility class for browsing of course files.
20  *
21  * @package    core_files
22  * @copyright  2008 Petr Skoda (http://skodak.org)
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 defined('MOODLE_INTERNAL') || die();
28 /**
29  * Represents a course context in the tree navigated by {@link file_browser}.
30  *
31  * @package    core_files
32  * @copyright  2008 Petr Skoda (http://skodak.org)
33  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
34  */
35 class file_info_context_course extends file_info {
36     /** @var stdClass course object */
37     protected $course;
39     /** @var file_info_context_module[] cached child modules. See {@link get_child_module()} */
40     protected $childrenmodules = [];
42     /**
43      * Constructor
44      *
45      * @param file_browser $browser file browser instance
46      * @param stdClass $context context object
47      * @param stdClass $course course object
48      */
49     public function __construct($browser, $context, $course) {
50         parent::__construct($browser, $context);
51         $this->course   = $course;
52     }
54     /**
55      * Return information about this specific context level
56      *
57      * @param string $component component
58      * @param string $filearea file area
59      * @param int $itemid item ID
60      * @param string $filepath file path
61      * @param string $filename file name
62      * @return file_info|null file_info instance or null if not found or access not allowed
63      */
64     public function get_file_info($component, $filearea, $itemid, $filepath, $filename) {
65         // try to emulate require_login() tests here
66         if (!isloggedin()) {
67             return null;
68         }
70         if (!$this->course->visible and !has_capability('moodle/course:viewhiddencourses', $this->context)) {
71             return null;
72         }
74         if (!is_viewing($this->context) and !$this->browser->is_enrolled($this->course->id)) {
75             // no peaking here if not enrolled or inspector
76             return null;
77         }
79         if (empty($component)) {
80             return $this;
81         }
83         $methodname = "get_area_{$component}_{$filearea}";
85         if (method_exists($this, $methodname)) {
86             return $this->$methodname($itemid, $filepath, $filename);
87         }
89         return null;
90     }
92     /**
93      * Returns list of areas inside this course
94      *
95      * @param string $extensions Only return areas that have files with these extensions
96      * @param bool $returnemptyfolders return all areas always, if true it will ignore the previous argument
97      * @return array
98      */
99     protected function get_course_areas($extensions = '*', $returnemptyfolders = false) {
100         global $DB;
102         $allareas = [
103             'course_summary',
104             'course_overviewfiles',
105             'course_section',
106             'backup_section',
107             'backup_course',
108             'backup_automated',
109             'course_legacy'
110         ];
112         if ($returnemptyfolders) {
113             return $allareas;
114         }
116         $params1 = ['contextid' => $this->context->id, 'emptyfilename' => '.'];
117         $sql1 = "SELECT " . $DB->sql_concat('f.component', "'_'", 'f.filearea') . "
118             FROM {files} f
119             WHERE f.filename <> :emptyfilename AND f.contextid = :contextid ";
120         $sql3 = ' GROUP BY f.component, f.filearea';
121         list($sql2, $params2) = $this->build_search_files_sql($extensions);
122         $areaswithfiles = $DB->get_fieldset_sql($sql1 . $sql2 . $sql3, array_merge($params1, $params2));
124         return array_intersect($allareas, $areaswithfiles);
125     }
127     /**
128      * Gets a stored file for the course summary filearea directory
129      *
130      * @param int $itemid item ID
131      * @param string $filepath file path
132      * @param string $filename file name
133      * @return file_info|null file_info instance or null if not found or access not allowed
134      */
135     protected function get_area_course_summary($itemid, $filepath, $filename) {
136         global $CFG;
138         if (!has_capability('moodle/course:update', $this->context)) {
139             return null;
140         }
141         if (is_null($itemid)) {
142             return $this;
143         }
145         $fs = get_file_storage();
147         $filepath = is_null($filepath) ? '/' : $filepath;
148         $filename = is_null($filename) ? '.' : $filename;
149         if (!$storedfile = $fs->get_file($this->context->id, 'course', 'summary', 0, $filepath, $filename)) {
150             if ($filepath === '/' and $filename === '.') {
151                 $storedfile = new virtual_root_file($this->context->id, 'course', 'summary', 0);
152             } else {
153                 // not found
154                 return null;
155             }
156         }
157         $urlbase = $CFG->wwwroot.'/pluginfile.php';
158         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('areacourseintro', 'repository'), false, true, true, false);
159     }
161     /**
162      * Gets a stored file for the course images filearea directory
163      *
164      * @param int $itemid item ID
165      * @param string $filepath file path
166      * @param string $filename file name
167      * @return file_info|null file_info instance or null if not found or access not allowed
168      */
169     protected function get_area_course_overviewfiles($itemid, $filepath, $filename) {
170         global $CFG;
172         if (!has_capability('moodle/course:update', $this->context)) {
173             return null;
174         }
175         if (is_null($itemid)) {
176             return $this;
177         }
179         $fs = get_file_storage();
181         $filepath = is_null($filepath) ? '/' : $filepath;
182         $filename = is_null($filename) ? '.' : $filename;
183         if (!$storedfile = $fs->get_file($this->context->id, 'course', 'overviewfiles', 0, $filepath, $filename)) {
184             if ($filepath === '/' and $filename === '.') {
185                 $storedfile = new virtual_root_file($this->context->id, 'course', 'overviewfiles', 0);
186             } else {
187                 // not found
188                 return null;
189             }
190         }
191         $urlbase = $CFG->wwwroot.'/pluginfile.php';
192         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('areacourseoverviewfiles', 'repository'), false, true, true, false);
193     }
195     /**
196      * Gets a stored file for the course section filearea directory
197      *
198      * @param int $itemid item ID
199      * @param string $filepath file path
200      * @param string $filename file name
201      * @return file_info|null file_info instance or null if not found or access not allowed
202      */
203     protected function get_area_course_section($itemid, $filepath, $filename) {
204         global $CFG, $DB;
206         if (!has_capability('moodle/course:update', $this->context)) {
207             return null;
208         }
210         if (empty($itemid)) {
211             // list all sections
212             return new file_info_area_course_section($this->browser, $this->context, $this->course, $this);
213         }
215         if (!$section = $DB->get_record('course_sections', array('course'=>$this->course->id, 'id'=>$itemid))) {
216             return null; // does not exist
217         }
219         $fs = get_file_storage();
221         $filepath = is_null($filepath) ? '/' : $filepath;
222         $filename = is_null($filename) ? '.' : $filename;
223         if (!$storedfile = $fs->get_file($this->context->id, 'course', 'section', $itemid, $filepath, $filename)) {
224             if ($filepath === '/' and $filename === '.') {
225                 $storedfile = new virtual_root_file($this->context->id, 'course', 'section', $itemid);
226             } else {
227                 // not found
228                 return null;
229             }
230         }
231         $urlbase = $CFG->wwwroot.'/pluginfile.php';
232         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, $section->section, true, true, true, false);
233     }
235     /**
236      * Gets a stored file for the course legacy filearea directory
237      *
238      * @param int $itemid item ID
239      * @param string $filepath file path
240      * @param string $filename file name
241      * @return file_info|null file_info instance or null if not found or access not allowed
242      */
243     protected function get_area_course_legacy($itemid, $filepath, $filename) {
244         if (!has_capability('moodle/course:managefiles', $this->context)) {
245             return null;
246         }
248         if ($this->course->id != SITEID and $this->course->legacyfiles != 2) {
249             // bad luck, legacy course files not used any more
250         }
252         if (is_null($itemid)) {
253             return $this;
254         }
256         $fs = get_file_storage();
258         $filepath = is_null($filepath) ? '/' : $filepath;
259         $filename = is_null($filename) ? '.' : $filename;
260         if (!$storedfile = $fs->get_file($this->context->id, 'course', 'legacy', 0, $filepath, $filename)) {
261             if ($filepath === '/' and $filename === '.') {
262                 $storedfile = new virtual_root_file($this->context->id, 'course', 'legacy', 0);
263             } else {
264                 // not found
265                 return null;
266             }
267         }
269         return new file_info_area_course_legacy($this->browser, $this->context, $storedfile);
270     }
272     /**
273      * Gets a stored file for the backup course filearea directory
274      *
275      * @param int $itemid item ID
276      * @param string $filepath file path
277      * @param string $filename file name
278      * @return file_info|null file_info instance or null if not found or access not allowed
279      */
280     protected function get_area_backup_course($itemid, $filepath, $filename) {
281         global $CFG;
283         if (!has_capability('moodle/backup:backupcourse', $this->context) and !has_capability('moodle/restore:restorecourse', $this->context)) {
284             return null;
285         }
286         if (is_null($itemid)) {
287             return $this;
288         }
290         $fs = get_file_storage();
292         $filepath = is_null($filepath) ? '/' : $filepath;
293         $filename = is_null($filename) ? '.' : $filename;
294         if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'course', 0, $filepath, $filename)) {
295             if ($filepath === '/' and $filename === '.') {
296                 $storedfile = new virtual_root_file($this->context->id, 'backup', 'course', 0);
297             } else {
298                 // not found
299                 return null;
300             }
301         }
303         $downloadable = has_capability('moodle/backup:downloadfile', $this->context);
304         $uploadable   = has_capability('moodle/restore:uploadfile', $this->context);
306         $urlbase = $CFG->wwwroot.'/pluginfile.php';
307         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('coursebackup', 'repository'), false, $downloadable, $uploadable, false);
308     }
310     /**
311      * Gets a stored file for the automated backup filearea directory
312      *
313      * @param int $itemid item ID
314      * @param string $filepath file path
315      * @param string $filename file name
316      * @return file_info|null
317      */
318     protected function get_area_backup_automated($itemid, $filepath, $filename) {
319         global $CFG;
321         if (!has_capability('moodle/restore:viewautomatedfilearea', $this->context)) {
322             return null;
323         }
324         if (is_null($itemid)) {
325             return $this;
326         }
328         $fs = get_file_storage();
330         $filepath = is_null($filepath) ? '/' : $filepath;
331         $filename = is_null($filename) ? '.' : $filename;
332         if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'automated', 0, $filepath, $filename)) {
333             if ($filepath === '/' and $filename === '.') {
334                 $storedfile = new virtual_root_file($this->context->id, 'backup', 'automated', 0);
335             } else {
336                 // not found
337                 return null;
338             }
339         }
341         // Automated backup files are only downloadable if the user has both 'backup:downloadfile and 'restore:userinfo'.
342         $downloadable = has_capability('moodle/backup:downloadfile', $this->context) &&
343                         has_capability('moodle/restore:userinfo', $this->context);
344         $uploadable   = false;
346         $urlbase = $CFG->wwwroot.'/pluginfile.php';
347         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('automatedbackup', 'repository'), true, $downloadable, $uploadable, false);
348     }
350     /**
351      * Gets a stored file for the backup section filearea directory
352      *
353      * @param int $itemid item ID
354      * @param string $filepath file path
355      * @param string $filename file name
356      * @return file_info|null file_info instance or null if not found or access not allowed
357      */
358     protected function get_area_backup_section($itemid, $filepath, $filename) {
359         global $CFG, $DB;
361         if (!has_capability('moodle/backup:backupcourse', $this->context) and !has_capability('moodle/restore:restorecourse', $this->context)) {
362             return null;
363         }
365         if (empty($itemid)) {
366             // list all sections
367             return new file_info_area_backup_section($this->browser, $this->context, $this->course, $this);
368         }
370         if (!$section = $DB->get_record('course_sections', array('course'=>$this->course->id, 'id'=>$itemid))) {
371             return null; // does not exist
372         }
374         $fs = get_file_storage();
376         $filepath = is_null($filepath) ? '/' : $filepath;
377         $filename = is_null($filename) ? '.' : $filename;
378         if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'section', $itemid, $filepath, $filename)) {
379             if ($filepath === '/' and $filename === '.') {
380                 $storedfile = new virtual_root_file($this->context->id, 'backup', 'section', $itemid);
381             } else {
382                 // not found
383                 return null;
384             }
385         }
387         $downloadable = has_capability('moodle/backup:downloadfile', $this->context);
388         $uploadable   = has_capability('moodle/restore:uploadfile', $this->context);
390         $urlbase = $CFG->wwwroot.'/pluginfile.php';
391         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, $section->id, true, $downloadable, $uploadable, false);
392     }
394     /**
395      * Returns localised visible name.
396      *
397      * @return string
398      */
399     public function get_visible_name() {
400         return ($this->course->id == SITEID) ? get_string('frontpage', 'admin') : format_string(get_course_display_name_for_list($this->course), true, array('context'=>$this->context));
401     }
403     /**
404      * Whether or not new files or directories can be added
405      *
406      * @return bool
407      */
408     public function is_writable() {
409         return false;
410     }
412     /**
413      * Whether or not this is a directory
414      *
415      * @return bool
416      */
417     public function is_directory() {
418         return true;
419     }
421     /**
422      * Returns list of children.
423      *
424      * @return array of file_info instances
425      */
426     public function get_children() {
427         return $this->get_filtered_children('*', false, true);
428     }
430     /**
431      * Returns the child module if it is accessible by the current user
432      *
433      * @param cm_info|int $cm
434      * @return file_info_context_module|null
435      */
436     protected function get_child_module($cm) {
437         $cmid = is_object($cm) ? $cm->id : $cm;
438         if (!array_key_exists($cmid, $this->childrenmodules)) {
439             $this->childrenmodules[$cmid] = null;
440             if (!($cm instanceof cm_info)) {
441                 $cms = get_fast_modinfo($this->course)->cms;
442                 $cm = array_key_exists($cmid, $cms) ? $cms[$cmid] : null;
443             }
444             if ($cm && $cm->uservisible) {
445                 $this->childrenmodules[$cmid] = new file_info_context_module($this->browser,
446                     $cm->context, $this->course, $cm, $cm->modname);
447             }
448         }
449         return $this->childrenmodules[$cmid];
450     }
452     /**
453      * Help function to return files matching extensions or their count
454      *
455      * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
456      * @param bool|int $countonly if false returns the children, if an int returns just the
457      *    count of children but stops counting when $countonly number of children is reached
458      * @param bool $returnemptyfolders if true returns items that don't have matching files inside
459      * @return array|int array of file_info instances or the count
460      */
461     private function get_filtered_children($extensions = '*', $countonly = false, $returnemptyfolders = false) {
462         $children = array();
464         $courseareas = $this->get_course_areas($extensions, $returnemptyfolders);
465         foreach ($courseareas as $areaname) {
466             $area = explode('_', $areaname, 2);
467             if ($child = $this->get_file_info($area[0], $area[1], 0, '/', '.')) {
468                 $children[] = $child;
469                 if (($countonly !== false) && count($children) >= $countonly) {
470                     return $countonly;
471                 }
472             }
473         }
475         $cnt = count($children);
476         if (!has_capability('moodle/course:managefiles', $this->context)) {
477             // 'managefiles' capability is checked in every activity module callback.
478             // Don't even waste time on retrieving the modules if we can't browse the files anyway
479         } else {
480             if ($returnemptyfolders) {
481                 $modinfo = get_fast_modinfo($this->course);
482                 foreach ($modinfo->cms as $cminfo) {
483                     if ($child = $this->get_child_module($cminfo)) {
484                         $children[] = $child;
485                         $cnt++;
486                     }
487                 }
488             } else if ($moduleareas = $this->get_module_areas_with_files($extensions)) {
489                 // We found files in some of the modules.
490                 // Create array of children modules ordered with the same way as cms in modinfo.
491                 $modulechildren = array_fill_keys(array_keys(get_fast_modinfo($this->course)->get_cms()), null);
492                 foreach ($moduleareas as $area) {
493                     if ($modulechildren[$area->cmid]) {
494                         // We already found non-empty area within the same module, do not analyse other areas.
495                         continue;
496                     }
497                     if ($child = $this->get_child_module($area->cmid)) {
498                         if ($child->get_file_info($area->component, $area->filearea, $area->itemid, null, null)) {
499                             $modulechildren[$area->cmid] = $child;
500                             $cnt++;
501                             if (($countonly !== false) && $cnt >= $countonly) {
502                                 return $cnt;
503                             }
504                         }
505                     }
506                 }
507                 $children = array_merge($children, array_values(array_filter($modulechildren)));
508             }
509         }
511         if ($countonly !== false) {
512             return count($children);
513         }
514         return $children;
515     }
517     /**
518      * Returns list of areas inside the course modules that have files with the given extension
519      *
520      * @param string $extensions
521      * @return array
522      */
523     protected function get_module_areas_with_files($extensions = '*') {
524         global $DB;
526         $params1 = ['contextid' => $this->context->id,
527             'emptyfilename' => '.',
528             'contextlevel' => CONTEXT_MODULE,
529             'depth' => $this->context->depth + 1,
530             'pathmask' => $this->context->path . '/%'];
531         $sql1 = "SELECT ctx.id AS contextid, f.component, f.filearea, f.itemid, ctx.instanceid AS cmid, " .
532                 context_helper::get_preload_record_columns_sql('ctx') . "
533             FROM {files} f
534             INNER JOIN {context} ctx ON ctx.id = f.contextid
535             WHERE f.filename <> :emptyfilename
536               AND ctx.contextlevel = :contextlevel
537               AND ctx.depth = :depth
538               AND " . $DB->sql_like('ctx.path', ':pathmask') . " ";
539         $sql3 = ' GROUP BY ctx.id, f.component, f.filearea, f.itemid, ctx.instanceid,
540               ctx.path, ctx.depth, ctx.contextlevel
541             ORDER BY ctx.id, f.component, f.filearea, f.itemid';
542         list($sql2, $params2) = $this->build_search_files_sql($extensions);
543         $areas = [];
544         if ($rs = $DB->get_recordset_sql($sql1. $sql2 . $sql3, array_merge($params1, $params2))) {
545             foreach ($rs as $record) {
546                 context_helper::preload_from_record($record);
547                 $areas[] = $record;
548             }
549             $rs->close();
550         }
552         // Sort areas so 'backup' and 'intro' are in the beginning of the list, they are the easiest to check access to.
553         usort($areas, function($a, $b) {
554             $aeasy = ($a->filearea === 'intro' && substr($a->component, 0, 4) === 'mod_') ||
555                 ($a->filearea === 'activity' && $a->component === 'backup');
556             $beasy = ($b->filearea === 'intro' && substr($b->component, 0, 4) === 'mod_') ||
557                 ($b->filearea === 'activity' && $b->component === 'backup');
558             return $aeasy == $beasy ? 0 : ($aeasy ? -1 : 1);
559         });
560         return $areas;
561     }
563     /**
564      * Returns list of children which are either files matching the specified extensions
565      * or folders that contain at least one such file.
566      *
567      * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
568      * @return array of file_info instances
569      */
570     public function get_non_empty_children($extensions = '*') {
571         return $this->get_filtered_children($extensions, false);
572     }
574     /**
575      * Returns the number of children which are either files matching the specified extensions
576      * or folders containing at least one such file.
577      *
578      * @param string|array $extensions, for example '*' or array('.gif','.jpg')
579      * @param int $limit stop counting after at least $limit non-empty children are found
580      * @return int
581      */
582     public function count_non_empty_children($extensions = '*', $limit = 1) {
583         return $this->get_filtered_children($extensions, $limit);
584     }
586     /**
587      * Returns parent file_info instance
588      *
589      * @return file_info or null for root
590      */
591     public function get_parent() {
592         $parent = $this->context->get_parent_context();
593         return $this->browser->get_file_info($parent);
594     }
598 /**
599  * Subclass of file_info_stored for files in the course files area.
600  *
601  * @package   core_files
602  * @copyright 2008 Petr Skoda (http://skodak.org)
603  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
604  */
605 class file_info_area_course_legacy extends file_info_stored {
606     /**
607      * Constructor
608      *
609      * @param file_browser $browser file browser instance
610      * @param stdClass $context context object
611      * @param stored_file $storedfile stored_file instance
612      */
613     public function __construct($browser, $context, $storedfile) {
614         global $CFG;
615         $urlbase = $CFG->wwwroot.'/file.php';
616         parent::__construct($browser, $context, $storedfile, $urlbase, get_string('coursefiles'), false, true, true, false);
617     }
619     /**
620      * Returns file download url
621      *
622      * @param bool $forcedownload whether or not force download
623      * @param bool $https whether or not force https
624      * @return string url
625      */
626     public function get_url($forcedownload=false, $https=false) {
627         if (!$this->is_readable()) {
628             return null;
629         }
631         if ($this->lf->is_directory()) {
632             return null;
633         }
635         $filepath = $this->lf->get_filepath();
636         $filename = $this->lf->get_filename();
637         $courseid = $this->context->instanceid;
639         $path = '/'.$courseid.$filepath.$filename;
641         return file_encode_url($this->urlbase, $path, $forcedownload, $https);
642     }
644     /**
645      * Returns list of children.
646      *
647      * @return array of file_info instances
648      */
649     public function get_children() {
650         if (!$this->lf->is_directory()) {
651             return array();
652         }
654         $result = array();
655         $fs = get_file_storage();
657         $storedfiles = $fs->get_directory_files($this->context->id, 'course', 'legacy', 0, $this->lf->get_filepath(), false, true, "filepath ASC, filename ASC");
658         foreach ($storedfiles as $file) {
659             $result[] = new file_info_area_course_legacy($this->browser, $this->context, $file);
660         }
662         return $result;
663     }
665     /**
666      * Returns list of children which are either files matching the specified extensions
667      * or folders that contain at least one such file.
668      *
669      * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
670      * @return array of file_info instances
671      */
672     public function get_non_empty_children($extensions = '*') {
673         if (!$this->lf->is_directory()) {
674             return array();
675         }
677         $result = array();
678         $fs = get_file_storage();
680         $storedfiles = $fs->get_directory_files($this->context->id, 'course', 'legacy', 0,
681                                                 $this->lf->get_filepath(), false, true, "filepath, filename");
682         foreach ($storedfiles as $file) {
683             $extension = core_text::strtolower(pathinfo($file->get_filename(), PATHINFO_EXTENSION));
684             if ($file->is_directory() || $extensions === '*' || (!empty($extension) && in_array('.'.$extension, $extensions))) {
685                 $fileinfo = new file_info_area_course_legacy($this->browser, $this->context, $file, $this->urlbase, $this->topvisiblename,
686                                                  $this->itemidused, $this->readaccess, $this->writeaccess, false);
687                 if (!$file->is_directory() || $fileinfo->count_non_empty_children($extensions)) {
688                     $result[] = $fileinfo;
689                 }
690             }
691         }
693         return $result;
694     }
697 /**
698  * Represents a course category context in the tree navigated by {@link file_browser}.
699  *
700  * @package    core_files
701  * @copyright  2008 Petr Skoda (http://skodak.org)
702  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
703  */
704 class file_info_area_course_section extends file_info {
705     /** @var stdClass course object */
706     protected $course;
707     /** @var file_info_context_course course file info object */
708     protected $courseinfo;
710     /**
711      * Constructor
712      *
713      * @param file_browser $browser file browser instance
714      * @param stdClass $context context object
715      * @param stdClass $course course object
716      * @param file_info_context_course $courseinfo file info instance
717      */
718     public function __construct($browser, $context, $course, file_info_context_course $courseinfo) {
719         parent::__construct($browser, $context);
720         $this->course     = $course;
721         $this->courseinfo = $courseinfo;
722     }
724     /**
725      * Returns list of standard virtual file/directory identification.
726      * The difference from stored_file parameters is that null values
727      * are allowed in all fields
728      *
729      * @return array with keys contextid, filearea, itemid, filepath and filename
730      */
731     public function get_params() {
732         return array('contextid' => $this->context->id,
733                      'component' => 'course',
734                      'filearea'  => 'section',
735                      'itemid'    => null,
736                      'filepath'  => null,
737                      'filename'  => null);
738     }
740     /**
741      * Returns localised visible name.
742      *
743      * @return string
744      */
745     public function get_visible_name() {
746         //$format = $this->course->format;
747         $sectionsname = get_string("coursesectionsummaries");
749         return $sectionsname;
750     }
752     /**
753      * Return whether or not new files or directories can be added
754      *
755      * @return bool
756      */
757     public function is_writable() {
758         return false;
759     }
761     /**
762      * Return whether or not this is a empty area
763      *
764      * @return bool
765      */
766     public function is_empty_area() {
767         $fs = get_file_storage();
768         return $fs->is_area_empty($this->context->id, 'course', 'section');
769     }
771     /**
772      * Return whether or not this is a empty area
773      *
774      * @return bool
775      */
776     public function is_directory() {
777         return true;
778     }
780     /**
781      * Returns list of children.
782      *
783      * @return array of file_info instances
784      */
785     public function get_children() {
786         global $DB;
788         $children = array();
790         $course_sections = $DB->get_records('course_sections', array('course'=>$this->course->id), 'section');
791         foreach ($course_sections as $section) {
792             if ($child = $this->courseinfo->get_file_info('course', 'section', $section->id, '/', '.')) {
793                 $children[] = $child;
794             }
795         }
797         return $children;
798     }
800     /**
801      * Returns the number of children which are either files matching the specified extensions
802      * or folders containing at least one such file.
803      *
804      * @param string|array $extensions, for example '*' or array('.gif','.jpg')
805      * @param int $limit stop counting after at least $limit non-empty children are found
806      * @return int
807      */
808     public function count_non_empty_children($extensions = '*', $limit = 1) {
809         global $DB;
810         $params1 = array(
811             'courseid' => $this->course->id,
812             'contextid' => $this->context->id,
813             'component' => 'course',
814             'filearea' => 'section',
815             'emptyfilename' => '.');
816         $sql1 = "SELECT DISTINCT cs.id FROM {files} f, {course_sections} cs
817             WHERE cs.course = :courseid
818             AND f.contextid = :contextid
819             AND f.component = :component
820             AND f.filearea = :filearea
821             AND f.itemid = cs.id
822             AND f.filename <> :emptyfilename";
823         list($sql2, $params2) = $this->build_search_files_sql($extensions);
824         $rs = $DB->get_recordset_sql($sql1. ' '. $sql2, array_merge($params1, $params2));
825         $cnt = 0;
826         foreach ($rs as $record) {
827             if ((++$cnt) >= $limit) {
828                 break;
829             }
830         }
831         $rs->close();
832         return $cnt;
833     }
835     /**
836      * Returns parent file_info instance
837      *
838      * @return file_info|null file_info or null for root
839      */
840     public function get_parent() {
841         return $this->courseinfo;
842     }
846 /**
847  * Implementation of course section backup area
848  *
849  * @package    core_files
850  * @copyright  2008 Petr Skoda (http://skodak.org)
851  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
852  */
853 class file_info_area_backup_section extends file_info {
854     /** @var stdClass course object */
855     protected $course;
856     /** @var file_info_context_course course file info object */
857     protected $courseinfo;
859     /**
860      * Constructor
861      *
862      * @param file_browser $browser file browser instance
863      * @param stdClass $context context object
864      * @param stdClass $course course object
865      * @param file_info_context_course $courseinfo file info instance
866      */
867     public function __construct($browser, $context, $course, file_info_context_course $courseinfo) {
868         parent::__construct($browser, $context);
869         $this->course     = $course;
870         $this->courseinfo = $courseinfo;
871     }
873     /**
874      * Returns list of standard virtual file/directory identification.
875      * The difference from stored_file parameters is that null values
876      * are allowed in all fields
877      *
878      * @return array with keys contextid, component, filearea, itemid, filepath and filename
879      */
880     public function get_params() {
881         return array('contextid' => $this->context->id,
882                      'component' => 'backup',
883                      'filearea'  => 'section',
884                      'itemid'    => null,
885                      'filepath'  => null,
886                      'filename'  => null);
887     }
889     /**
890      * Returns localised visible name.
891      *
892      * @return string
893      */
894     public function get_visible_name() {
895         return get_string('sectionbackup', 'repository');
896     }
898     /**
899      * Return whether or not new files and directories can be added
900      *
901      * @return bool
902      */
903     public function is_writable() {
904         return false;
905     }
907     /**
908      * Whether or not this is an empty area
909      *
910      * @return bool
911      */
912     public function is_empty_area() {
913         $fs = get_file_storage();
914         return $fs->is_area_empty($this->context->id, 'backup', 'section');
915     }
917     /**
918      * Return whether or not this is a directory
919      *
920      * @return bool
921      */
922     public function is_directory() {
923         return true;
924     }
926     /**
927      * Returns list of children.
928      *
929      * @return array of file_info instances
930      */
931     public function get_children() {
932         global $DB;
934         $children = array();
936         $course_sections = $DB->get_records('course_sections', array('course'=>$this->course->id), 'section');
937         foreach ($course_sections as $section) {
938             if ($child = $this->courseinfo->get_file_info('backup', 'section', $section->id, '/', '.')) {
939                 $children[] = $child;
940             }
941         }
943         return $children;
944     }
946     /**
947      * Returns the number of children which are either files matching the specified extensions
948      * or folders containing at least one such file.
949      *
950      * @param string|array $extensions, for example '*' or array('.gif','.jpg')
951      * @param int $limit stop counting after at least $limit non-empty children are found
952      * @return int
953      */
954     public function count_non_empty_children($extensions = '*', $limit = 1) {
955         global $DB;
956         $params1 = array(
957             'courseid' => $this->course->id,
958             'contextid' => $this->context->id,
959             'component' => 'backup',
960             'filearea' => 'section',
961             'emptyfilename' => '.');
962         $sql1 = "SELECT DISTINCT cs.id AS sectionid FROM {files} f, {course_sections} cs
963             WHERE cs.course = :courseid
964             AND f.contextid = :contextid
965             AND f.component = :component
966             AND f.filearea = :filearea
967             AND f.itemid = cs.id
968             AND f.filename <> :emptyfilename";
969         list($sql2, $params2) = $this->build_search_files_sql($extensions);
970         $rs = $DB->get_recordset_sql($sql1. ' '. $sql2, array_merge($params1, $params2));
971         $cnt = 0;
972         foreach ($rs as $record) {
973             if ((++$cnt) >= $limit) {
974                 break;
975             }
976         }
977         $rs->close();
978         return $cnt;
979     }
981     /**
982      * Returns parent file_info instance
983      *
984      * @return file_info or null for root
985      */
986     public function get_parent() {
987         return $this->browser->get_file_info($this->context);
988     }