21504fe2184188a8ccc82d0d6c3abc27fd3a42d8
[moodle.git] / privacy / classes / local / request / moodle_content_writer.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/>.
17 /**
18  * This file contains the moodle format implementation of the content writer.
19  *
20  * @package core_privacy
21  * @copyright 2018 Andrew Nicols <andrew@nicols.co.uk>
22  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
24 namespace core_privacy\local\request;
26 defined('MOODLE_INTERNAL') || die();
28 /**
29  * The moodle_content_writer is the default Moodle implementation of a content writer.
30  *
31  * It exports data to a rich tree structure using Moodle's context system,
32  * and produces a single zip file with all content.
33  *
34  * Objects of data are stored as JSON.
35  *
36  * @copyright 2018 Andrew Nicols <andrew@nicols.co.uk>
37  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
38  */
39 class moodle_content_writer implements content_writer {
40     /**
41      * @var string The base path on disk for this instance.
42      */
43     protected $path = null;
45     /**
46      * @var \context The current context of the writer.
47      */
48     protected $context = null;
50     /**
51      * @var \stored_file[] The list of files to be exported.
52      */
53     protected $files = [];
55     /**
56      * @var array The list of plugins that have been checked to see if they are installed.
57      */
58     protected $checkedplugins = [];
60     /**
61      * Constructor for the content writer.
62      *
63      * Note: The writer factory must be passed.
64      *
65      * @param   writer          $writer     The factory.
66      */
67     public function __construct(writer $writer) {
68         $this->path = make_request_directory();
69     }
71     /**
72      * Set the context for the current item being processed.
73      *
74      * @param   \context        $context    The context to use
75      */
76     public function set_context(\context $context) : content_writer {
77         $this->context = $context;
79         return $this;
80     }
82     /**
83      * Export the supplied data within the current context, at the supplied subcontext.
84      *
85      * @param   array           $subcontext The location within the current context that this data belongs.
86      * @param   \stdClass       $data       The data to be exported
87      * @return  content_writer
88      */
89     public function export_data(array $subcontext, \stdClass $data) : content_writer {
90         $path = $this->get_path($subcontext, 'data.json');
92         $this->write_data($path, json_encode($data, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT));
94         return $this;
95     }
97     /**
98      * Export metadata about the supplied subcontext.
99      *
100      * Metadata consists of a key/value pair and a description of the value.
101      *
102      * @param   array           $subcontext The location within the current context that this data belongs.
103      * @param   string          $key        The metadata name.
104      * @param   string          $value      The metadata value.
105      * @param   string          $description    The description of the value.
106      * @return  content_writer
107      */
108     public function export_metadata(array $subcontext, string $key, $value, string $description) : content_writer {
109         $path = $this->get_full_path($subcontext, 'metadata.json');
111         if (file_exists($path)) {
112             $data = json_decode(file_get_contents($path));
113         } else {
114             $data = (object) [];
115         }
117         $data->$key = (object) [
118             'value' => $value,
119             'description' => $description,
120         ];
122         $path = $this->get_path($subcontext, 'metadata.json');
123         $this->write_data($path, json_encode($data, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT));
125         return $this;
126     }
128     /**
129      * Export a piece of related data.
130      *
131      * @param   array           $subcontext The location within the current context that this data belongs.
132      * @param   string          $name       The name of the file to be exported.
133      * @param   \stdClass       $data       The related data to export.
134      * @return  content_writer
135      */
136     public function export_related_data(array $subcontext, $name, $data) : content_writer {
137         $path = $this->get_path($subcontext, "{$name}.json");
139         $this->write_data($path, json_encode($data, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT));
141         return $this;
142     }
144     /**
145      * Export a piece of data in a custom format.
146      *
147      * @param   array           $subcontext The location within the current context that this data belongs.
148      * @param   string          $filename   The name of the file to be exported.
149      * @param   string          $filecontent    The content to be exported.
150      */
151     public function export_custom_file(array $subcontext, $filename, $filecontent) : content_writer {
152         $filename = clean_param($filename, PARAM_FILE);
153         $path = $this->get_path($subcontext, $filename);
154         $this->write_data($path, $filecontent);
156         return $this;
157     }
159     /**
160      * Prepare a text area by processing pluginfile URLs within it.
161      *
162      * @param   array           $subcontext The location within the current context that this data belongs.
163      * @param   string          $component  The name of the component that the files belong to.
164      * @param   string          $filearea   The filearea within that component.
165      * @param   string          $itemid     Which item those files belong to.
166      * @param   string          $text       The text to be processed
167      * @return  string                      The processed string
168      */
169     public function rewrite_pluginfile_urls(array $subcontext, $component, $filearea, $itemid, $text) : string {
170         // Need to take into consideration the subcontext to provide the full path to this file.
171         $subcontextpath = '';
172         if (!empty($subcontext)) {
173             $subcontextpath = DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $subcontext);
174         }
175         $path = $this->get_context_path();
176         $path = implode(DIRECTORY_SEPARATOR, $path) . $subcontextpath;
177         $returnstring = $path . DIRECTORY_SEPARATOR . $this->get_files_target_url($component, $filearea, $itemid) . '/';
178         $returnstring = clean_param($returnstring, PARAM_PATH);
180         return str_replace('@@PLUGINFILE@@/', $returnstring, $text);
181     }
183     /**
184      * Export all files within the specified component, filearea, itemid combination.
185      *
186      * @param   array           $subcontext The location within the current context that this data belongs.
187      * @param   string          $component  The name of the component that the files belong to.
188      * @param   string          $filearea   The filearea within that component.
189      * @param   string          $itemid     Which item those files belong to.
190      */
191     public function export_area_files(array $subcontext, $component, $filearea, $itemid) : content_writer {
192         $fs = get_file_storage();
193         $files = $fs->get_area_files($this->context->id, $component, $filearea, $itemid);
194         foreach ($files as $file) {
195             $this->export_file($subcontext, $file);
196         }
198         return $this;
199     }
201     /**
202      * Export the specified file in the target location.
203      *
204      * @param   array           $subcontext The location within the current context that this data belongs.
205      * @param   \stored_file    $file       The file to be exported.
206      */
207     public function export_file(array $subcontext, \stored_file $file) : content_writer {
208         if (!$file->is_directory()) {
209             $pathitems = array_merge(
210                 $subcontext,
211                 [$this->get_files_target_path($file->get_component(), $file->get_filearea(), $file->get_itemid())],
212                 [$file->get_filepath()]
213             );
214             $path = $this->get_path($pathitems, $file->get_filename());
215             check_dir_exists(dirname($path), true, true);
216             $this->files[$path] = $file;
217         }
219         return $this;
220     }
222     /**
223      * Export the specified user preference.
224      *
225      * @param   string          $component  The name of the component.
226      * @param   string          $key        The name of th key to be exported.
227      * @param   string          $value      The value of the preference
228      * @param   string          $description    A description of the value
229      * @return  content_writer
230      */
231     public function export_user_preference(string $component, string $key, string $value, string $description) : content_writer {
232         $subcontext = [
233             get_string('userpreferences'),
234         ];
235         $fullpath = $this->get_full_path($subcontext, "{$component}.json");
236         $path = $this->get_path($subcontext, "{$component}.json");
238         if (file_exists($fullpath)) {
239             $data = json_decode(file_get_contents($fullpath));
240         } else {
241             $data = (object) [];
242         }
244         $data->$key = (object) [
245             'value' => $value,
246             'description' => $description,
247         ];
248         $this->write_data($path, json_encode($data, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT));
250         return $this;
251     }
253     /**
254      * Determine the path for the current context.
255      *
256      * @return  array                       The context path.
257      */
258     protected function get_context_path() : Array {
259         $path = [];
260         $contexts = array_reverse($this->context->get_parent_contexts(true));
261         foreach ($contexts as $context) {
262             $name = $context->get_context_name();
263             $id = '_.' . $context->id;
264             $path[] = shorten_filename(clean_param("{$name} {$id}", PARAM_FILE), MAX_FILENAME_SIZE, true);
265         }
267         return $path;
268     }
270     /**
271      * Get the relative file path within the current context, and subcontext, using the specified filename.
272      *
273      * @param   string[]        $subcontext The location within the current context to export this data.
274      * @param   string          $name       The intended filename, including any extensions.
275      * @return  string                      The fully-qualfiied file path.
276      */
277     protected function get_path(array $subcontext, string $name) : string {
278         $subcontext = shorten_filenames($subcontext, MAX_FILENAME_SIZE, true);
279         $name = shorten_filename($name, MAX_FILENAME_SIZE, true);
281         // This weird code is to look for a subcontext that contains a number and append an '_' to the front.
282         // This is because there seems to be some weird problem with array_merge_recursive used in finalise_content().
283         $subcontext = array_map(function($data) {
284             if (stripos($data, DIRECTORY_SEPARATOR) !== false) {
285                 $newpath = explode(DIRECTORY_SEPARATOR, $data);
286                 $newpath = array_map(function($value) {
287                     if (is_numeric($value)) {
288                         return '_' . $value;
289                     }
290                     return $value;
291                 }, $newpath);
292                 return implode(DIRECTORY_SEPARATOR, $newpath);
293             } else if (is_numeric($data)) {
294                 $data = '_' . $data;
295             }
296             return $data;
297         }, $subcontext);
299         // Combine the context path, and the subcontext data.
300         $path = array_merge(
301             $this->get_context_path(),
302             $subcontext
303         );
305         // Join the directory together with the name.
306         $filepath = implode(DIRECTORY_SEPARATOR, $path) . DIRECTORY_SEPARATOR . $name;
308         // To use backslash, it must be doubled ("\\\\" PHP string).
309         $separator = str_replace('\\', '\\\\', DIRECTORY_SEPARATOR);
310         return preg_replace('@(' . $separator . '|/)+@', $separator, $filepath);
311     }
313     /**
314      * Get the fully-qualified file path within the current context, and subcontext, using the specified filename.
315      *
316      * @param   string[]        $subcontext The location within the current context to export this data.
317      * @param   string          $name       The intended filename, including any extensions.
318      * @return  string                      The fully-qualfiied file path.
319      */
320     protected function get_full_path(array $subcontext, string $name) : string {
321         $path = array_merge(
322             [$this->path],
323             [$this->get_path($subcontext, $name)]
324         );
326         // Join the directory together with the name.
327         $filepath = implode(DIRECTORY_SEPARATOR, $path);
329         // To use backslash, it must be doubled ("\\\\" PHP string).
330         $separator = str_replace('\\', '\\\\', DIRECTORY_SEPARATOR);
331         return preg_replace('@(' . $separator . '|/)+@', $separator, $filepath);
332     }
334     /**
335      * Get a path within a subcontext where exported files should be written to.
336      *
337      * @param string $component The name of the component that the files belong to.
338      * @param string $filearea The filearea within that component.
339      * @param string $itemid Which item those files belong to.
340      * @return string The path
341      */
342     protected function get_files_target_path($component, $filearea, $itemid) : string {
344         // We do not need to include the component because we organise things by context.
345         $parts = ['_files', $filearea];
347         if (!empty($itemid)) {
348             $parts[] = $itemid;
349         }
351         return implode(DIRECTORY_SEPARATOR, $parts);
352     }
354     /**
355      * Get a relative url to the directory of the exported files within a subcontext.
356      *
357      * @param string $component The name of the component that the files belong to.
358      * @param string $filearea The filearea within that component.
359      * @param string $itemid Which item those files belong to.
360      * @return string The url
361      */
362     protected function get_files_target_url($component, $filearea, $itemid) : string {
363         // We do not need to include the component because we organise things by context.
364         $parts = ['_files', $filearea];
366         if (!empty($itemid)) {
367             $parts[] = '_' . $itemid;
368         }
370         return implode('/', $parts);
371     }
373     /**
374      * Write the data to the specified path.
375      *
376      * @param   string          $path       The path to export the data at.
377      * @param   string          $data       The data to be exported.
378      */
379     protected function write_data(string $path, string $data) {
380         $targetpath = $this->path . DIRECTORY_SEPARATOR . $path;
381         check_dir_exists(dirname($targetpath), true, true);
382         file_put_contents($targetpath, $data);
383         $this->files[$path] = $targetpath;
384     }
386     /**
387      * Copy a file to the specified path.
388      *
389      * @param  array  $path        Current location of the file.
390      * @param  array  $destination Destination path to copy the file to.
391      */
392     protected function copy_data(array $path, array $destination) {
393         // Do we not have a moodle function to do something like this?
394         $systempath = getcwd();
395         // This is likely to be running from admin/cli.
396         if (stripos($systempath, 'admin' . DIRECTORY_SEPARATOR . 'cli') !== false) {
397             $bits = explode('admin' . DIRECTORY_SEPARATOR . 'cli', $systempath);
398             $systempath = implode('', $bits);
399         }
400         $filename = array_pop($destination);
401         $destdirectory = implode(DIRECTORY_SEPARATOR, $destination);
402         $fulldestination = $this->path . DIRECTORY_SEPARATOR . $destdirectory;
403         check_dir_exists($fulldestination, true, true);
404         $fulldestination .= $filename;
405         $currentpath = $systempath . DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $path);
406         copy($currentpath, $fulldestination);
407         $this->files[$destdirectory . DIRECTORY_SEPARATOR . $filename] = $fulldestination;
408     }
410     /**
411      * This creates three different bits of data from all of the files that will be
412      * exported.
413      * $tree - A multidimensional array of the navigation tree structure.
414      * $treekey - An array with the short path of the file and element data for
415      *            html (data_file_{number} or 'No var')
416      * $allfiles - All *.json files that need to be added as an index to be referenced
417      *             by the js files to display the user data.
418      *
419      * @return array returns a tree, tree key, and a list of all files.
420      */
421     protected function prepare_for_export() : Array {
422         $tree = [];
423         $treekey = [];
424         $allfiles = [];
425         $i = 1;
426         foreach ($this->files as $shortpath => $fullfile) {
428             // Generate directory tree as an associative array.
429             $items = explode(DIRECTORY_SEPARATOR, $shortpath);
430             $newitems = $this->condense_array($items);
431             $tree = array_merge_recursive($tree, $newitems);
433             if (is_string($fullfile)) {
434                 $filearray = explode(DIRECTORY_SEPARATOR, $shortpath);
435                 $filename = array_pop($filearray);
436                 $filenamearray = explode('.', $filename);
437                 // Don't process files that are not json files.
438                 if (end($filenamearray) !== 'json') {
439                     continue;
440                 }
441                 // Chop the last two characters of the extension. json => js.
442                 $filename = substr($filename, 0, -2);
443                 array_push($filearray, $filename);
444                 $newshortpath = implode(DIRECTORY_SEPARATOR, $filearray);
446                 $varname = 'data_file_' . $i;
447                 $i++;
449                 $quicktemp = clean_param($shortpath, PARAM_PATH);
450                 $treekey[$quicktemp] = $varname;
451                 $allfiles[$varname] = clean_param($newshortpath, PARAM_PATH);
453                 // Need to load up the current json file and add a variable (varname mentioned above) at the start.
454                 // Then save it as a js file.
455                 $content = $this->get_file_content($fullfile);
456                 $jsondecodedcontent = json_decode($content);
457                 $jsonencodedcontent = json_encode($jsondecodedcontent, JSON_PRETTY_PRINT);
458                 $variablecontent = 'var ' . $varname . ' = ' . $jsonencodedcontent;
460                 $this->write_data($newshortpath, $variablecontent);
461             } else {
462                 $treekey[$shortpath] = 'No var';
463             }
464         }
465         return [$tree, $treekey, $allfiles];
466     }
468     /**
469      * Add more detail to the tree to help with sorting and display in the renderer.
470      *
471      * @param  array  $tree       The file structure currently as a multidimensional array.
472      * @param  array  $treekey    An array of the current file paths.
473      * @param  array  $currentkey The current short path of the tree.
474      * @return array An array of objects that has additional data.
475      */
476     protected function make_tree_object(array $tree, array $treekey, array $currentkey = []) : Array {
477         $newtree = [];
478         // Try to extract the context id and then add the context object.
479         $addcontext = function($index, $object) {
480             if (stripos($index, '_.') !== false) {
481                 $namearray = explode('_.', $index);
482                 $contextid = array_pop($namearray);
483                 if (is_numeric($contextid)) {
484                     $object[$index]->name = implode('_.', $namearray);
485                     $object[$index]->context = \context::instance_by_id($contextid);
486                 }
487             } else {
488                 $object[$index]->name = $index;
489             }
490         };
491         // Just add the final data to the tree object.
492         $addfinalfile = function($directory, $treeleaf, $file) use ($treekey) {
493             $url = implode(DIRECTORY_SEPARATOR, $directory);
494             $url = clean_param($url, PARAM_PATH);
495             $treeleaf->name = $file;
496             $treeleaf->itemtype = 'item';
497             $gokey = $url . DIRECTORY_SEPARATOR . $file;
498             if (isset($treekey[$gokey]) && $treekey[$gokey] !== 'No var') {
499                 $treeleaf->datavar = $treekey[$gokey];
500             } else {
501                 $treeleaf->url = new \moodle_url($url . DIRECTORY_SEPARATOR . $file);
502             }
503         };
505         foreach ($tree as $key => $value) {
506             $newtree[$key] = new \stdClass();
507             if (is_array($value)) {
508                 $newtree[$key]->itemtype = 'treeitem';
509                 // The array merge recursive adds a numeric index, and so we only add to the current
510                 // key if it is now numeric.
511                 $currentkey = is_numeric($key) ? $currentkey : array_merge($currentkey, [$key]);
513                 // Try to extract the context id and then add the context object.
514                 $addcontext($key, $newtree);
515                 $newtree[$key]->children = $this->make_tree_object($value, $treekey, $currentkey);
517                 if (!is_numeric($key)) {
518                     // We're heading back down the tree, so remove the last key.
519                     array_pop($currentkey);
520                 }
521             } else {
522                 // If the key is not numeric then we want to add a directory and put the file under that.
523                 if (!is_numeric($key)) {
524                     $newtree[$key]->itemtype = 'treeitem';
525                     // Try to extract the context id and then add the context object.
526                     $addcontext($key, $newtree);
527                      array_push($currentkey, $key);
529                     $newtree[$key]->children[$value] = new \stdClass();
530                     $addfinalfile($currentkey, $newtree[$key]->children[$value], $value);
531                     array_pop($currentkey);
532                 } else {
533                     // If the key is just a number then we just want to show the file instead.
534                     $addfinalfile($currentkey, $newtree[$key], $value);
535                 }
536             }
537         }
538         return $newtree;
539     }
541     /**
542      * Sorts the tree list into an order that makes more sense.
543      * Order is:
544      * 1 - Items with a context first, the lower the number the higher up the tree.
545      * 2 - Items that are directories.
546      * 3 - Items that are log directories.
547      * 4 - Links to a page.
548      *
549      * @param  array $tree The tree structure to order.
550      */
551     protected function sort_my_list(array &$tree) {
552         uasort($tree, function($a, $b) {
553             if (isset($a->context) && isset($b->context)) {
554                 return $a->context->contextlevel <=> $b->context->contextlevel;
555             }
556             if (isset($a->context) && !isset($b->context)) {
557                 return -1;
558             }
559             if (isset($b->context) && !isset($a->context)) {
560                 return 1;
561             }
562             if ($a->itemtype == 'treeitem' && $b->itemtype == 'treeitem') {
563                 // Ugh need to check that this plugin has not been uninstalled.
564                 if ($this->check_plugin_is_installed('tool_log')) {
565                     if (trim($a->name) == get_string('privacy:path:logs', 'tool_log')) {
566                         return 1;
567                     } else if (trim($b->name) == get_string('privacy:path:logs', 'tool_log')) {
568                         return -1;
569                     }
570                     return 0;
571                 }
572             }
573             if ($a->itemtype == 'treeitem' && $b->itemtype == 'item') {
574                 return -1;
575             }
576             if ($b->itemtype == 'treeitem' && $a->itemtype == 'item') {
577                 return 1;
578             }
579             return 0;
580         });
581         foreach ($tree as $treeobject) {
582             if (isset($treeobject->children)) {
583                 $this->sort_my_list($treeobject->children);
584             }
585         }
586     }
588     /**
589      * Check to see if a specified plugin is installed.
590      *
591      * @param  string $component The component name e.g. tool_log
592      * @return bool Whether this component is installed.
593      */
594     protected function check_plugin_is_installed(string $component) : Bool {
595         if (!isset($this->checkedplugins[$component])) {
596             $pluginmanager = \core_plugin_manager::instance();
597             $plugin = $pluginmanager->get_plugin_info($component);
598             $this->checkedplugins[$component] = !is_null($plugin);
599         }
600         return $this->checkedplugins[$component];
601     }
603     /**
604      * Writes the appropriate files for creating an HTML index page for human navigation of the user data export.
605      */
606     protected function write_html_data() {
607         global $PAGE, $SITE, $USER, $CFG;
609         // Do this first before adding more files to $this->files.
610         list($tree, $treekey, $allfiles) = $this->prepare_for_export();
611         // Add more detail to the tree such as contexts.
612         $richtree = $this->make_tree_object($tree, $treekey);
613         // Now that we have more detail we can use that to sort it.
614         $this->sort_my_list($richtree);
616         // Copy over the JavaScript required to display the html page.
617         $jspath = ['privacy', 'export_files', 'general.js'];
618         $targetpath = ['js', 'general.js'];
619         $this->copy_data($jspath, $targetpath);
621         $jquery = ['lib', 'jquery', 'jquery-3.2.1.min.js'];
622         $jquerydestination = ['js', 'jquery-3.2.1.min.js'];
623         $this->copy_data($jquery, $jquerydestination);
625         $requirecurrentpath = ['lib', 'requirejs', 'require.min.js'];
626         $destination = ['js', 'require.min.js'];
627         $this->copy_data($requirecurrentpath, $destination);
629         $treepath = ['lib', 'amd', 'build', 'tree.min.js'];
630         $destination = ['js', 'tree.min.js'];
631         $this->copy_data($treepath, $destination);
633         // Icons to be used.
634         $expandediconpath = ['pix', 't', 'expanded.svg'];
635         $this->copy_data($expandediconpath, ['pix', 'expanded.svg']);
636         $collapsediconpath = ['pix', 't', 'collapsed.svg'];
637         $this->copy_data($collapsediconpath, ['pix', 'collapsed.svg']);
638         $naviconpath = ['pix', 'i', 'navigationitem.svg'];
639         $this->copy_data($naviconpath, ['pix', 'navigationitem.svg']);
640         $moodleimgpath = ['pix', 'moodlelogo.svg'];
641         $this->copy_data($moodleimgpath, ['pix', 'moodlelogo.svg']);
643         // Additional required css.
644         // Determine what direction to show the data export page according to the user preference.
645         $rtl = right_to_left();
646         if (!$rtl) {
647             $bootstrapdestination = 'bootstrap.min.css';
648             $this->write_url_content('https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css',
649                     $bootstrapdestination);
650         } else {
651             $rtldestination = 'rtlbootstrap.min.css';
652             $this->write_url_content('https://cdn.rtlcss.com/bootstrap/v4.0.0/css/bootstrap.min.css', $rtldestination);
653         }
655         $csspath = ['privacy', 'export_files', 'general.css'];
656         $destination = ['general.css'];
657         $this->copy_data($csspath, $destination);
659         // Create an index file that lists all, to be newly created, js files.
660         $encoded = json_encode($allfiles,  JSON_PRETTY_PRINT);
661         $encoded = 'var user_data_index = ' . $encoded;
663         $path = 'js' . DIRECTORY_SEPARATOR . 'data_index.js';
664         $this->write_data($path, $encoded);
666         $output = $PAGE->get_renderer('core_privacy');
667         $navigationpage = new \core_privacy\output\exported_navigation_page(current($richtree));
668         $navigationhtml = $output->render_navigation($navigationpage);
670         $systemname = $SITE->fullname;
671         $fullusername = fullname($USER);
672         $siteurl = $CFG->wwwroot;
674         // Create custom index.html file.
675         $htmlpage = new \core_privacy\output\exported_html_page($navigationhtml, $systemname, $fullusername, $rtl, $siteurl);
676         $outputpage = $output->render_html_page($htmlpage);
677         $this->write_data('index.html', $outputpage);
678     }
680     /**
681      * Perform any required finalisation steps and return the location of the finalised export.
682      *
683      * @return  string
684      */
685     public function finalise_content() : string {
686         $this->write_html_data();
688         $exportfile = make_request_directory() . '/export.zip';
690         $fp = get_file_packer();
691         $fp->archive_to_pathname($this->files, $exportfile);
693         // Reset the writer to prevent any further writes.
694         writer::reset();
696         return $exportfile;
697     }
699     /**
700      * Creates a multidimensional array out of array elements.
701      *
702      * @param  array  $array Array which items are to be condensed into a multidimensional array.
703      * @return array The multidimensional array.
704      */
705     protected function condense_array(array $array) : Array {
706         if (count($array) === 2) {
707             return [$array[0] => $array[1]];
708         }
709         if (isset($array[0])) {
710             return [$array[0] => $this->condense_array(array_slice($array, 1))];
711         }
712         return [];
713     }
715     /**
716      * Get the contents of a file.
717      *
718      * @param  string $filepath The file path.
719      * @return string contents of the file.
720      */
721     protected function get_file_content(string $filepath) : String {
722         $filepointer = fopen($filepath, 'r');
723         $content = '';
724         while (!feof($filepointer)) {
725             $content .= fread($filepointer, filesize($filepath));
726         }
727         return $content;
728     }
730     /**
731      * Write url files to the export.
732      *
733      * @param  string $url  Url of the file.
734      * @param  string $path Path to store the file.
735      */
736     protected function write_url_content(string $url, string $path) {
737         $filepointer = fopen($url, 'r');
738         $targetpath = $this->path . DIRECTORY_SEPARATOR . $path;
739         check_dir_exists(dirname($targetpath), true, true);
740         $status = file_put_contents($targetpath, $filepointer);
741         if ($status === false) {
742             // There was an error. Throw an exception to allow the download status to remain as requiring download.
743             throw new \moodle_exception('Content download was incomplete');
744         }
745         $this->files[$path] = $targetpath;
746     }