MDL-53566 core: Add support for context locking
[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         require_once($CFG->dirroot.'/course/lib.php');
233         $sectionname = get_section_name($this->course, $section);
234         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, $sectionname, true, true, true, false);
235     }
237     /**
238      * Gets a stored file for the course legacy filearea directory
239      *
240      * @param int $itemid item ID
241      * @param string $filepath file path
242      * @param string $filename file name
243      * @return file_info|null file_info instance or null if not found or access not allowed
244      */
245     protected function get_area_course_legacy($itemid, $filepath, $filename) {
246         if (!has_capability('moodle/course:managefiles', $this->context)) {
247             return null;
248         }
250         if ($this->course->id != SITEID and $this->course->legacyfiles != 2) {
251             // bad luck, legacy course files not used any more
252         }
254         if (is_null($itemid)) {
255             return $this;
256         }
258         $fs = get_file_storage();
260         $filepath = is_null($filepath) ? '/' : $filepath;
261         $filename = is_null($filename) ? '.' : $filename;
262         if (!$storedfile = $fs->get_file($this->context->id, 'course', 'legacy', 0, $filepath, $filename)) {
263             if ($filepath === '/' and $filename === '.') {
264                 $storedfile = new virtual_root_file($this->context->id, 'course', 'legacy', 0);
265             } else {
266                 // not found
267                 return null;
268             }
269         }
271         return new file_info_area_course_legacy($this->browser, $this->context, $storedfile);
272     }
274     /**
275      * Gets a stored file for the backup course filearea directory
276      *
277      * @param int $itemid item ID
278      * @param string $filepath file path
279      * @param string $filename file name
280      * @return file_info|null file_info instance or null if not found or access not allowed
281      */
282     protected function get_area_backup_course($itemid, $filepath, $filename) {
283         global $CFG;
285         if (!has_capability('moodle/backup:backupcourse', $this->context) and !has_capability('moodle/restore:restorecourse', $this->context)) {
286             return null;
287         }
288         if (is_null($itemid)) {
289             return $this;
290         }
292         $fs = get_file_storage();
294         $filepath = is_null($filepath) ? '/' : $filepath;
295         $filename = is_null($filename) ? '.' : $filename;
296         if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'course', 0, $filepath, $filename)) {
297             if ($filepath === '/' and $filename === '.') {
298                 $storedfile = new virtual_root_file($this->context->id, 'backup', 'course', 0);
299             } else {
300                 // not found
301                 return null;
302             }
303         }
305         $downloadable = has_capability('moodle/backup:downloadfile', $this->context);
306         $uploadable   = has_capability('moodle/restore:uploadfile', $this->context);
308         $urlbase = $CFG->wwwroot.'/pluginfile.php';
309         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('coursebackup', 'repository'), false, $downloadable, $uploadable, false);
310     }
312     /**
313      * Gets a stored file for the automated backup filearea directory
314      *
315      * @param int $itemid item ID
316      * @param string $filepath file path
317      * @param string $filename file name
318      * @return file_info|null
319      */
320     protected function get_area_backup_automated($itemid, $filepath, $filename) {
321         global $CFG;
323         if (!has_capability('moodle/restore:viewautomatedfilearea', $this->context)) {
324             return null;
325         }
326         if (is_null($itemid)) {
327             return $this;
328         }
330         $fs = get_file_storage();
332         $filepath = is_null($filepath) ? '/' : $filepath;
333         $filename = is_null($filename) ? '.' : $filename;
334         if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'automated', 0, $filepath, $filename)) {
335             if ($filepath === '/' and $filename === '.') {
336                 $storedfile = new virtual_root_file($this->context->id, 'backup', 'automated', 0);
337             } else {
338                 // not found
339                 return null;
340             }
341         }
343         // Automated backup files are only downloadable if the user has both 'backup:downloadfile and 'restore:userinfo'.
344         $downloadable = has_capability('moodle/backup:downloadfile', $this->context) &&
345                         has_capability('moodle/restore:userinfo', $this->context);
346         $uploadable   = false;
348         $urlbase = $CFG->wwwroot.'/pluginfile.php';
349         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('automatedbackup', 'repository'), true, $downloadable, $uploadable, false);
350     }
352     /**
353      * Gets a stored file for the backup section filearea directory
354      *
355      * @param int $itemid item ID
356      * @param string $filepath file path
357      * @param string $filename file name
358      * @return file_info|null file_info instance or null if not found or access not allowed
359      */
360     protected function get_area_backup_section($itemid, $filepath, $filename) {
361         global $CFG, $DB;
363         if (!has_capability('moodle/backup:backupcourse', $this->context) and !has_capability('moodle/restore:restorecourse', $this->context)) {
364             return null;
365         }
367         if (empty($itemid)) {
368             // list all sections
369             return new file_info_area_backup_section($this->browser, $this->context, $this->course, $this);
370         }
372         if (!$section = $DB->get_record('course_sections', array('course'=>$this->course->id, 'id'=>$itemid))) {
373             return null; // does not exist
374         }
376         $fs = get_file_storage();
378         $filepath = is_null($filepath) ? '/' : $filepath;
379         $filename = is_null($filename) ? '.' : $filename;
380         if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'section', $itemid, $filepath, $filename)) {
381             if ($filepath === '/' and $filename === '.') {
382                 $storedfile = new virtual_root_file($this->context->id, 'backup', 'section', $itemid);
383             } else {
384                 // not found
385                 return null;
386             }
387         }
389         $downloadable = has_capability('moodle/backup:downloadfile', $this->context);
390         $uploadable   = has_capability('moodle/restore:uploadfile', $this->context);
392         $urlbase = $CFG->wwwroot.'/pluginfile.php';
393         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, $section->id, true, $downloadable, $uploadable, false);
394     }
396     /**
397      * Returns localised visible name.
398      *
399      * @return string
400      */
401     public function get_visible_name() {
402         return ($this->course->id == SITEID) ? get_string('frontpage', 'admin') : format_string(get_course_display_name_for_list($this->course), true, array('context'=>$this->context));
403     }
405     /**
406      * Whether or not new files or directories can be added
407      *
408      * @return bool
409      */
410     public function is_writable() {
411         return false;
412     }
414     /**
415      * Whether or not this is a directory
416      *
417      * @return bool
418      */
419     public function is_directory() {
420         return true;
421     }
423     /**
424      * Returns list of children.
425      *
426      * @return array of file_info instances
427      */
428     public function get_children() {
429         return $this->get_filtered_children('*', false, true);
430     }
432     /**
433      * Returns the child module if it is accessible by the current user
434      *
435      * @param cm_info|int $cm
436      * @return file_info_context_module|null
437      */
438     protected function get_child_module($cm) {
439         $cmid = is_object($cm) ? $cm->id : $cm;
440         if (!array_key_exists($cmid, $this->childrenmodules)) {
441             $this->childrenmodules[$cmid] = null;
442             if (!($cm instanceof cm_info)) {
443                 $cms = get_fast_modinfo($this->course)->cms;
444                 $cm = array_key_exists($cmid, $cms) ? $cms[$cmid] : null;
445             }
446             if ($cm && $cm->uservisible) {
447                 $this->childrenmodules[$cmid] = new file_info_context_module($this->browser,
448                     $cm->context, $this->course, $cm, $cm->modname);
449             }
450         }
451         return $this->childrenmodules[$cmid];
452     }
454     /**
455      * Help function to return files matching extensions or their count
456      *
457      * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
458      * @param bool|int $countonly if false returns the children, if an int returns just the
459      *    count of children but stops counting when $countonly number of children is reached
460      * @param bool $returnemptyfolders if true returns items that don't have matching files inside
461      * @return array|int array of file_info instances or the count
462      */
463     private function get_filtered_children($extensions = '*', $countonly = false, $returnemptyfolders = false) {
464         $children = array();
466         $courseareas = $this->get_course_areas($extensions, $returnemptyfolders);
467         foreach ($courseareas as $areaname) {
468             $area = explode('_', $areaname, 2);
469             if ($child = $this->get_file_info($area[0], $area[1], 0, '/', '.')) {
470                 $children[] = $child;
471                 if (($countonly !== false) && count($children) >= $countonly) {
472                     return $countonly;
473                 }
474             }
475         }
477         $cnt = count($children);
478         if (!has_capability('moodle/course:managefiles', $this->context)) {
479             // 'managefiles' capability is checked in every activity module callback.
480             // Don't even waste time on retrieving the modules if we can't browse the files anyway
481         } else {
482             if ($returnemptyfolders) {
483                 $modinfo = get_fast_modinfo($this->course);
484                 foreach ($modinfo->cms as $cminfo) {
485                     if ($child = $this->get_child_module($cminfo)) {
486                         $children[] = $child;
487                         $cnt++;
488                     }
489                 }
490             } else if ($moduleareas = $this->get_module_areas_with_files($extensions)) {
491                 // We found files in some of the modules.
492                 // Create array of children modules ordered with the same way as cms in modinfo.
493                 $modulechildren = array_fill_keys(array_keys(get_fast_modinfo($this->course)->get_cms()), null);
494                 foreach ($moduleareas as $area) {
495                     if ($modulechildren[$area->cmid]) {
496                         // We already found non-empty area within the same module, do not analyse other areas.
497                         continue;
498                     }
499                     if ($child = $this->get_child_module($area->cmid)) {
500                         if ($child->get_file_info($area->component, $area->filearea, $area->itemid, null, null)) {
501                             $modulechildren[$area->cmid] = $child;
502                             $cnt++;
503                             if (($countonly !== false) && $cnt >= $countonly) {
504                                 return $cnt;
505                             }
506                         }
507                     }
508                 }
509                 $children = array_merge($children, array_values(array_filter($modulechildren)));
510             }
511         }
513         if ($countonly !== false) {
514             return count($children);
515         }
516         return $children;
517     }
519     /**
520      * Returns list of areas inside the course modules that have files with the given extension
521      *
522      * @param string $extensions
523      * @return array
524      */
525     protected function get_module_areas_with_files($extensions = '*') {
526         global $DB;
528         $params1 = ['contextid' => $this->context->id,
529             'emptyfilename' => '.',
530             'contextlevel' => CONTEXT_MODULE,
531             'depth' => $this->context->depth + 1,
532             'pathmask' => $this->context->path . '/%'];
533         $ctxfieldsas = context_helper::get_preload_record_columns_sql('ctx');
534         $ctxfields = implode(', ', array_keys(context_helper::get_preload_record_columns('ctx')));
535         $sql1 = "SELECT
536                     ctx.id AS contextid,
537                     f.component,
538                     f.filearea,
539                     f.itemid,
540                     ctx.instanceid AS cmid,
541                     {$ctxfieldsas}
542             FROM {files} f
543             INNER JOIN {context} ctx ON ctx.id = f.contextid
544             WHERE f.filename <> :emptyfilename
545               AND ctx.contextlevel = :contextlevel
546               AND ctx.depth = :depth
547               AND " . $DB->sql_like('ctx.path', ':pathmask') . " ";
548         $sql3 = "
549             GROUP BY ctx.id, f.component, f.filearea, f.itemid, {$ctxfields}
550             ORDER BY ctx.id, f.component, f.filearea, f.itemid";
551         list($sql2, $params2) = $this->build_search_files_sql($extensions);
552         $areas = [];
553         if ($rs = $DB->get_recordset_sql($sql1. $sql2 . $sql3, array_merge($params1, $params2))) {
554             foreach ($rs as $record) {
555                 context_helper::preload_from_record($record);
556                 $areas[] = $record;
557             }
558             $rs->close();
559         }
561         // Sort areas so 'backup' and 'intro' are in the beginning of the list, they are the easiest to check access to.
562         usort($areas, function($a, $b) {
563             $aeasy = ($a->filearea === 'intro' && substr($a->component, 0, 4) === 'mod_') ||
564                 ($a->filearea === 'activity' && $a->component === 'backup');
565             $beasy = ($b->filearea === 'intro' && substr($b->component, 0, 4) === 'mod_') ||
566                 ($b->filearea === 'activity' && $b->component === 'backup');
567             return $aeasy == $beasy ? 0 : ($aeasy ? -1 : 1);
568         });
569         return $areas;
570     }
572     /**
573      * Returns list of children which are either files matching the specified extensions
574      * or folders that contain at least one such file.
575      *
576      * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
577      * @return array of file_info instances
578      */
579     public function get_non_empty_children($extensions = '*') {
580         return $this->get_filtered_children($extensions, false);
581     }
583     /**
584      * Returns the number of children which are either files matching the specified extensions
585      * or folders containing at least one such file.
586      *
587      * @param string|array $extensions, for example '*' or array('.gif','.jpg')
588      * @param int $limit stop counting after at least $limit non-empty children are found
589      * @return int
590      */
591     public function count_non_empty_children($extensions = '*', $limit = 1) {
592         return $this->get_filtered_children($extensions, $limit);
593     }
595     /**
596      * Returns parent file_info instance
597      *
598      * @return file_info or null for root
599      */
600     public function get_parent() {
601         $parent = $this->context->get_parent_context();
602         return $this->browser->get_file_info($parent);
603     }
607 /**
608  * Subclass of file_info_stored for files in the course files area.
609  *
610  * @package   core_files
611  * @copyright 2008 Petr Skoda (http://skodak.org)
612  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
613  */
614 class file_info_area_course_legacy extends file_info_stored {
615     /**
616      * Constructor
617      *
618      * @param file_browser $browser file browser instance
619      * @param stdClass $context context object
620      * @param stored_file $storedfile stored_file instance
621      */
622     public function __construct($browser, $context, $storedfile) {
623         global $CFG;
624         $urlbase = $CFG->wwwroot.'/file.php';
625         parent::__construct($browser, $context, $storedfile, $urlbase, get_string('coursefiles'), false, true, true, false);
626     }
628     /**
629      * Returns file download url
630      *
631      * @param bool $forcedownload whether or not force download
632      * @param bool $https whether or not force https
633      * @return string url
634      */
635     public function get_url($forcedownload=false, $https=false) {
636         if (!$this->is_readable()) {
637             return null;
638         }
640         if ($this->lf->is_directory()) {
641             return null;
642         }
644         $filepath = $this->lf->get_filepath();
645         $filename = $this->lf->get_filename();
646         $courseid = $this->context->instanceid;
648         $path = '/'.$courseid.$filepath.$filename;
650         return file_encode_url($this->urlbase, $path, $forcedownload, $https);
651     }
653     /**
654      * Returns list of children.
655      *
656      * @return array of file_info instances
657      */
658     public function get_children() {
659         if (!$this->lf->is_directory()) {
660             return array();
661         }
663         $result = array();
664         $fs = get_file_storage();
666         $storedfiles = $fs->get_directory_files($this->context->id, 'course', 'legacy', 0, $this->lf->get_filepath(), false, true, "filepath ASC, filename ASC");
667         foreach ($storedfiles as $file) {
668             $result[] = new file_info_area_course_legacy($this->browser, $this->context, $file);
669         }
671         return $result;
672     }
674     /**
675      * Returns list of children which are either files matching the specified extensions
676      * or folders that contain at least one such file.
677      *
678      * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
679      * @return array of file_info instances
680      */
681     public function get_non_empty_children($extensions = '*') {
682         if (!$this->lf->is_directory()) {
683             return array();
684         }
686         $result = array();
687         $fs = get_file_storage();
689         $storedfiles = $fs->get_directory_files($this->context->id, 'course', 'legacy', 0,
690                                                 $this->lf->get_filepath(), false, true, "filepath, filename");
691         foreach ($storedfiles as $file) {
692             $extension = core_text::strtolower(pathinfo($file->get_filename(), PATHINFO_EXTENSION));
693             if ($file->is_directory() || $extensions === '*' || (!empty($extension) && in_array('.'.$extension, $extensions))) {
694                 $fileinfo = new file_info_area_course_legacy($this->browser, $this->context, $file, $this->urlbase, $this->topvisiblename,
695                                                  $this->itemidused, $this->readaccess, $this->writeaccess, false);
696                 if (!$file->is_directory() || $fileinfo->count_non_empty_children($extensions)) {
697                     $result[] = $fileinfo;
698                 }
699             }
700         }
702         return $result;
703     }
706 /**
707  * Represents a course category context in the tree navigated by {@link file_browser}.
708  *
709  * @package    core_files
710  * @copyright  2008 Petr Skoda (http://skodak.org)
711  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
712  */
713 class file_info_area_course_section extends file_info {
714     /** @var stdClass course object */
715     protected $course;
716     /** @var file_info_context_course course file info object */
717     protected $courseinfo;
719     /**
720      * Constructor
721      *
722      * @param file_browser $browser file browser instance
723      * @param stdClass $context context object
724      * @param stdClass $course course object
725      * @param file_info_context_course $courseinfo file info instance
726      */
727     public function __construct($browser, $context, $course, file_info_context_course $courseinfo) {
728         parent::__construct($browser, $context);
729         $this->course     = $course;
730         $this->courseinfo = $courseinfo;
731     }
733     /**
734      * Returns list of standard virtual file/directory identification.
735      * The difference from stored_file parameters is that null values
736      * are allowed in all fields
737      *
738      * @return array with keys contextid, filearea, itemid, filepath and filename
739      */
740     public function get_params() {
741         return array('contextid' => $this->context->id,
742                      'component' => 'course',
743                      'filearea'  => 'section',
744                      'itemid'    => null,
745                      'filepath'  => null,
746                      'filename'  => null);
747     }
749     /**
750      * Returns localised visible name.
751      *
752      * @return string
753      */
754     public function get_visible_name() {
755         //$format = $this->course->format;
756         $sectionsname = get_string("coursesectionsummaries");
758         return $sectionsname;
759     }
761     /**
762      * Return whether or not new files or directories can be added
763      *
764      * @return bool
765      */
766     public function is_writable() {
767         return false;
768     }
770     /**
771      * Return whether or not this is a empty area
772      *
773      * @return bool
774      */
775     public function is_empty_area() {
776         $fs = get_file_storage();
777         return $fs->is_area_empty($this->context->id, 'course', 'section');
778     }
780     /**
781      * Return whether or not this is a empty area
782      *
783      * @return bool
784      */
785     public function is_directory() {
786         return true;
787     }
789     /**
790      * Returns list of children.
791      *
792      * @return array of file_info instances
793      */
794     public function get_children() {
795         global $DB;
797         $children = array();
799         $course_sections = $DB->get_records('course_sections', array('course'=>$this->course->id), 'section');
800         foreach ($course_sections as $section) {
801             if ($child = $this->courseinfo->get_file_info('course', 'section', $section->id, '/', '.')) {
802                 $children[] = $child;
803             }
804         }
806         return $children;
807     }
809     /**
810      * Returns the number of children which are either files matching the specified extensions
811      * or folders containing at least one such file.
812      *
813      * @param string|array $extensions, for example '*' or array('.gif','.jpg')
814      * @param int $limit stop counting after at least $limit non-empty children are found
815      * @return int
816      */
817     public function count_non_empty_children($extensions = '*', $limit = 1) {
818         global $DB;
819         $params1 = array(
820             'courseid' => $this->course->id,
821             'contextid' => $this->context->id,
822             'component' => 'course',
823             'filearea' => 'section',
824             'emptyfilename' => '.');
825         $sql1 = "SELECT DISTINCT cs.id FROM {files} f, {course_sections} cs
826             WHERE cs.course = :courseid
827             AND f.contextid = :contextid
828             AND f.component = :component
829             AND f.filearea = :filearea
830             AND f.itemid = cs.id
831             AND f.filename <> :emptyfilename";
832         list($sql2, $params2) = $this->build_search_files_sql($extensions);
833         $rs = $DB->get_recordset_sql($sql1. ' '. $sql2, array_merge($params1, $params2));
834         $cnt = 0;
835         foreach ($rs as $record) {
836             if ((++$cnt) >= $limit) {
837                 break;
838             }
839         }
840         $rs->close();
841         return $cnt;
842     }
844     /**
845      * Returns parent file_info instance
846      *
847      * @return file_info|null file_info or null for root
848      */
849     public function get_parent() {
850         return $this->courseinfo;
851     }
855 /**
856  * Implementation of course section backup area
857  *
858  * @package    core_files
859  * @copyright  2008 Petr Skoda (http://skodak.org)
860  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
861  */
862 class file_info_area_backup_section extends file_info {
863     /** @var stdClass course object */
864     protected $course;
865     /** @var file_info_context_course course file info object */
866     protected $courseinfo;
868     /**
869      * Constructor
870      *
871      * @param file_browser $browser file browser instance
872      * @param stdClass $context context object
873      * @param stdClass $course course object
874      * @param file_info_context_course $courseinfo file info instance
875      */
876     public function __construct($browser, $context, $course, file_info_context_course $courseinfo) {
877         parent::__construct($browser, $context);
878         $this->course     = $course;
879         $this->courseinfo = $courseinfo;
880     }
882     /**
883      * Returns list of standard virtual file/directory identification.
884      * The difference from stored_file parameters is that null values
885      * are allowed in all fields
886      *
887      * @return array with keys contextid, component, filearea, itemid, filepath and filename
888      */
889     public function get_params() {
890         return array('contextid' => $this->context->id,
891                      'component' => 'backup',
892                      'filearea'  => 'section',
893                      'itemid'    => null,
894                      'filepath'  => null,
895                      'filename'  => null);
896     }
898     /**
899      * Returns localised visible name.
900      *
901      * @return string
902      */
903     public function get_visible_name() {
904         return get_string('sectionbackup', 'repository');
905     }
907     /**
908      * Return whether or not new files and directories can be added
909      *
910      * @return bool
911      */
912     public function is_writable() {
913         return false;
914     }
916     /**
917      * Whether or not this is an empty area
918      *
919      * @return bool
920      */
921     public function is_empty_area() {
922         $fs = get_file_storage();
923         return $fs->is_area_empty($this->context->id, 'backup', 'section');
924     }
926     /**
927      * Return whether or not this is a directory
928      *
929      * @return bool
930      */
931     public function is_directory() {
932         return true;
933     }
935     /**
936      * Returns list of children.
937      *
938      * @return array of file_info instances
939      */
940     public function get_children() {
941         global $DB;
943         $children = array();
945         $course_sections = $DB->get_records('course_sections', array('course'=>$this->course->id), 'section');
946         foreach ($course_sections as $section) {
947             if ($child = $this->courseinfo->get_file_info('backup', 'section', $section->id, '/', '.')) {
948                 $children[] = $child;
949             }
950         }
952         return $children;
953     }
955     /**
956      * Returns the number of children which are either files matching the specified extensions
957      * or folders containing at least one such file.
958      *
959      * @param string|array $extensions, for example '*' or array('.gif','.jpg')
960      * @param int $limit stop counting after at least $limit non-empty children are found
961      * @return int
962      */
963     public function count_non_empty_children($extensions = '*', $limit = 1) {
964         global $DB;
965         $params1 = array(
966             'courseid' => $this->course->id,
967             'contextid' => $this->context->id,
968             'component' => 'backup',
969             'filearea' => 'section',
970             'emptyfilename' => '.');
971         $sql1 = "SELECT DISTINCT cs.id AS sectionid FROM {files} f, {course_sections} cs
972             WHERE cs.course = :courseid
973             AND f.contextid = :contextid
974             AND f.component = :component
975             AND f.filearea = :filearea
976             AND f.itemid = cs.id
977             AND f.filename <> :emptyfilename";
978         list($sql2, $params2) = $this->build_search_files_sql($extensions);
979         $rs = $DB->get_recordset_sql($sql1. ' '. $sql2, array_merge($params1, $params2));
980         $cnt = 0;
981         foreach ($rs as $record) {
982             if ((++$cnt) >= $limit) {
983                 break;
984             }
985         }
986         $rs->close();
987         return $cnt;
988     }
990     /**
991      * Returns parent file_info instance
992      *
993      * @return file_info or null for root
994      */
995     public function get_parent() {
996         return $this->browser->get_file_info($this->context);
997     }