1<?php
2
3// This file is part of Moodle - http://moodle.org/
4//
5// Moodle is free software: you can redistribute it and/or modify
6// it under the terms of the GNU General Public License as published by
7// the Free Software Foundation, either version 3 of the License, or
8// (at your option) any later version.
9//
10// Moodle is distributed in the hope that it will be useful,
11// but WITHOUT ANY WARRANTY; without even the implied warranty of
12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13// GNU General Public License for more details.
14//
15// You should have received a copy of the GNU General Public License
16// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17
18/**
19 * Draft file ajax file manager
20 *
21 * @package    core
22 * @subpackage repository
23 * @copyright  2010 Dongsheng Cai <dongsheng@moodle.com>
24 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
25 */
26
27define('AJAX_SCRIPT', true);
28
29require('../config.php');
30require_once($CFG->libdir.'/filelib.php');
31require_once($CFG->libdir.'/adminlib.php');
32require_once($CFG->dirroot.'/repository/lib.php');
33$PAGE->set_context(context_system::instance());
34require_login();
35if (isguestuser()) {
36    print_error('noguest');
37}
38require_sesskey();
39
40$action  = required_param('action', PARAM_ALPHA);
41$draftid = required_param('itemid', PARAM_INT);
42$filepath = optional_param('filepath', '/', PARAM_PATH);
43
44$usercontext = context_user::instance($USER->id);
45
46echo $OUTPUT->header(); // send headers
47
48//
49//NOTE TO ALL DEVELOPERS: this script must deal only with draft area of current user, it has to use only file_storage and no file_browser!!
50//
51
52switch ($action) {
53    case 'dir':
54        $data = new stdClass();
55        file_get_drafarea_folders($draftid, $filepath, $data);
56        echo json_encode($data);
57        die;
58
59    case 'list':
60        $filepath = optional_param('filepath', '/', PARAM_PATH);
61
62        $data = repository::prepare_listing(file_get_drafarea_files($draftid, $filepath));
63        $info = file_get_draft_area_info($draftid);
64        $data->filecount = $info['filecount'];
65        $data->filesize = $info['filesize'];
66        $data->tree = new stdClass();
67        file_get_drafarea_folders($draftid, '/', $data->tree);
68        echo json_encode($data);
69        die;
70
71    case 'mkdir':
72        $filepath   = required_param('filepath', PARAM_PATH);
73        $newdirname = required_param('newdirname', PARAM_FILE);
74
75        $fs = get_file_storage();
76        $fs->create_directory($usercontext->id, 'user', 'draft', $draftid, file_correct_filepath(file_correct_filepath($filepath).$newdirname));
77        $return = new stdClass();
78        $return->filepath = $filepath;
79        echo json_encode($return);
80        die;
81
82    case 'delete':
83        $filename   = required_param('filename', PARAM_FILE);
84        $filepath   = required_param('filepath', PARAM_PATH);
85        $selectedfile = (object)[
86            'filename' => $filename,
87            'filepath' => $filepath
88        ];
89        $return = repository_delete_selected_files($usercontext, 'user', 'draft', $draftid, [$selectedfile]);
90
91        if ($return) {
92            $response = new stdClass();
93            $response->filepath = array_keys($return)[0];
94            echo json_encode($response);
95            die;
96        }
97
98        echo json_encode(false);
99        die;
100
101    case 'deleteselected':
102        $selected   = required_param('selected', PARAM_RAW);
103        $return = [];
104        $selectedfiles = json_decode($selected);
105        $return = repository_delete_selected_files($usercontext, 'user', 'draft', $draftid, $selectedfiles);
106        echo (json_encode($return ? array_keys($return) : false));
107        die;
108
109    case 'setmainfile':
110        $filename   = required_param('filename', PARAM_FILE);
111        $filepath   = required_param('filepath', PARAM_PATH);
112
113        $filepath = file_correct_filepath($filepath);
114        // reset sort order
115        file_reset_sortorder($usercontext->id, 'user', 'draft', $draftid);
116        // set main file
117        $return = file_set_sortorder($usercontext->id, 'user', 'draft', $draftid, $filepath, $filename, 1);
118        echo json_encode($return);
119        die;
120
121    case 'updatefile':
122        // Allows to Rename file, move it to another directory, change it's license and author information in one request
123        $filename    = required_param('filename', PARAM_FILE);
124        $filepath    = required_param('filepath', PARAM_PATH);
125        $updatedata = array();
126        $updatedata['filename'] = optional_param('newfilename', $filename, PARAM_FILE);
127        $updatedata['filepath'] = $newfilepath = optional_param('newfilepath', $filepath, PARAM_PATH);
128        if (($v = optional_param('newlicense', false, PARAM_TEXT)) !== false) {
129            $updatedata['license'] = $v;
130        }
131        if (($v = optional_param('newauthor', false, PARAM_TEXT)) !== false) {
132            $updatedata['author'] = $v;
133        }
134        try {
135            repository::update_draftfile($draftid, $filepath, $filename, $updatedata);
136        } catch (moodle_exception $e) {
137            die(json_encode((object)array('error' => $e->getMessage())));
138        }
139        die(json_encode((object)array('filepath' => $newfilepath)));
140
141    case 'updatedir':
142        $filepath = required_param('filepath', PARAM_PATH);
143        $newdirname = required_param('newdirname', PARAM_FILE);
144        $parent = required_param('newfilepath', PARAM_PATH);
145        $newfilepath = clean_param($parent . '/' . $newdirname . '/', PARAM_PATH);
146        try {
147            repository::update_draftfile($draftid, $filepath, '.', array('filepath' => $newfilepath));
148        } catch (moodle_exception $e) {
149            die(json_encode((object)array('error' => $e->getMessage())));
150        }
151        die(json_encode((object)array('filepath' => $parent)));
152
153    case 'zip':
154        $filepath = required_param('filepath', PARAM_PATH);
155
156        $zipper = get_file_packer('application/zip');
157        $fs = get_file_storage();
158
159        $file = $fs->get_file($usercontext->id, 'user', 'draft', $draftid, $filepath, '.');
160
161        $parent_path = $file->get_parent_directory()->get_filepath();
162
163        $filepath = explode('/', trim($file->get_filepath(), '/'));
164        $filepath = array_pop($filepath);
165        $zipfile = repository::get_unused_filename($draftid, $parent_path, $filepath . '.zip');
166
167        if ($newfile = $zipper->archive_to_storage([$filepath => $file], $usercontext->id, 'user', 'draft', $draftid, $parent_path, $zipfile, $USER->id)) {
168            $return = new stdClass();
169            $return->filepath = $parent_path;
170            echo json_encode($return);
171        } else {
172            echo json_encode(false);
173        }
174        die;
175    case 'downloadselected':
176        $selected   = required_param('selected', PARAM_RAW);
177        $selectedfiles = json_decode($selected);
178        if (!count($selectedfiles)) {
179            $filepath = required_param('filepath', PARAM_PATH);
180            $selectedfiles = [(object)[
181                'filename' => '',
182                'filepath' => $filepath
183            ]];
184        }
185        $return = repository_download_selected_files($usercontext, 'user', 'draft', $draftid, $selectedfiles);
186        echo (json_encode($return));
187        die;
188
189    case 'downloaddir':
190        $filepath = required_param('filepath', PARAM_PATH);
191
192        $selectedfile = (object)[
193            'filename' => '',
194            'filepath' => $filepath
195        ];
196        $return = repository_download_selected_files($usercontext, 'user', 'draft', $draftid, [$selectedfile]);
197        echo json_encode($return);
198        die;
199
200    case 'unzip':
201        $filename = required_param('filename', PARAM_FILE);
202        $filepath = required_param('filepath', PARAM_PATH);
203        $areamaxbytes = required_param('areamaxbytes', PARAM_INT);
204
205        $return = new stdClass();
206        $zipper = get_file_packer('application/zip');
207        $fs = get_file_storage();
208        $file = $fs->get_file($usercontext->id, 'user', 'draft', $draftid, $filepath, $filename);
209        // Get the total size of the content in the archive.
210        $filecontentsize = $file->get_total_content_size($zipper);
211
212        // Return an error if the returned size of the content is NULL.
213        // This means the utility class was unable to read the content of the archive.
214        if (is_null($filecontentsize)) {
215            $return->error = get_string('cannotunzipcontentunreadable', 'repository');
216            die(json_encode($return));
217        }
218
219        // Check whether the maximum size allowed in this draft area will be exceeded with unzipping the file.
220        // If the maximum size allowed is exceeded, return an error before attempting to unzip.
221        if (file_is_draft_area_limit_reached($draftid, $areamaxbytes, $filecontentsize)) {
222            $return->error = get_string('cannotunzipquotaexceeded', 'repository');
223            die(json_encode($return));
224        }
225
226        // Find unused name for directory to extract the archive.
227        $temppath = $fs->get_unused_dirname($usercontext->id, 'user', 'draft', $draftid, $filepath. pathinfo($filename, PATHINFO_FILENAME). '/');
228        $donotremovedirs = array();
229        $doremovedirs = array($temppath);
230
231        // Extract archive and move all files from $temppath to $filepath
232        if (($processed = $file->extract_to_storage($zipper, $usercontext->id, 'user', 'draft', $draftid, $temppath, $USER->id))
233                !== false) {
234
235            // Find all failures within the processed files, and return an error if any are found.
236            $failed = array_filter($processed, static function($result): bool {
237                return $result !== true;
238            });
239            if (count($failed) > 0) {
240                $return->error = get_string('cannotunzipextractfileerror',  'repository');
241                die(json_encode($return));
242            }
243
244            $extractedfiles = $fs->get_directory_files($usercontext->id, 'user', 'draft', $draftid, $temppath, true);
245            $xtemppath = preg_quote($temppath, '|');
246            foreach ($extractedfiles as $file) {
247                $realpath = preg_replace('|^'.$xtemppath.'|', $filepath, $file->get_filepath());
248                if (!$file->is_directory()) {
249                    // Set the source to the extracted file to indicate that it came from archive.
250                    $file->set_source(serialize((object)array('source' => $filepath)));
251                }
252                if (!$fs->file_exists($usercontext->id, 'user', 'draft', $draftid, $realpath, $file->get_filename())) {
253                    // File or directory did not exist, just move it.
254                    $file->rename($realpath, $file->get_filename());
255                } else if (!$file->is_directory()) {
256                    // File already existed, overwrite it
257                    repository::overwrite_existing_draftfile($draftid, $realpath, $file->get_filename(), $file->get_filepath(), $file->get_filename());
258                } else {
259                    // Directory already existed, remove temporary dir but make sure we don't remove the existing dir
260                    $doremovedirs[] = $file->get_filepath();
261                    $donotremovedirs[] = $realpath;
262                }
263            }
264            $return->filepath = $filepath;
265        } else {
266            $return = false;
267        }
268        // Remove remaining temporary directories.
269        foreach (array_diff($doremovedirs, $donotremovedirs) as $filepath) {
270            if ($file = $fs->get_file($usercontext->id, 'user', 'draft', $draftid, $filepath, '.')) {
271                $file->delete();
272            }
273        }
274        die(json_encode($return));
275
276    case 'getoriginal':
277        $filename    = required_param('filename', PARAM_FILE);
278        $filepath    = required_param('filepath', PARAM_PATH);
279
280        $fs = get_file_storage();
281        $file = $fs->get_file($usercontext->id, 'user', 'draft', $draftid, $filepath, $filename);
282        if (!$file) {
283            echo json_encode(false);
284        } else {
285            $return = array('filename' => $filename, 'filepath' => $filepath, 'original' => $file->get_reference_details());
286            echo json_encode((object)$return);
287        }
288        die;
289
290    case 'getreferences':
291        $filename    = required_param('filename', PARAM_FILE);
292        $filepath    = required_param('filepath', PARAM_PATH);
293
294        $fs = get_file_storage();
295        $file = $fs->get_file($usercontext->id, 'user', 'draft', $draftid, $filepath, $filename);
296        if (!$file) {
297            echo json_encode(false);
298        } else {
299            $source = unserialize($file->get_source());
300            $return = array('filename' => $filename, 'filepath' => $filepath, 'references' => array());
301            $browser = get_file_browser();
302            if (isset($source->original)) {
303                $reffiles = $fs->search_references($source->original);
304                foreach ($reffiles as $reffile) {
305                    $refcontext = context::instance_by_id($reffile->get_contextid());
306                    $fileinfo = $browser->get_file_info($refcontext, $reffile->get_component(), $reffile->get_filearea(), $reffile->get_itemid(), $reffile->get_filepath(), $reffile->get_filename());
307                    if (empty($fileinfo)) {
308                        $return['references'][] = get_string('undisclosedreference', 'repository');
309                    } else {
310                        $return['references'][] = $fileinfo->get_readable_fullname();
311                    }
312                }
313            }
314            echo json_encode((object)$return);
315        }
316        die;
317
318    default:
319        // no/unknown action?
320        echo json_encode(false);
321        die;
322}
323