Merge branch 'MDL-62016_master' of git://github.com/dmonllao/moodle
[moodle.git] / admin / tool / dataprivacy / classes / output / data_registry_page.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  * Data registry renderable.
19  *
20  * @package    tool_dataprivacy
21  * @copyright  2018 David Monllao
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
24 namespace tool_dataprivacy\output;
25 defined('MOODLE_INTERNAL') || die();
27 use renderable;
28 use renderer_base;
29 use stdClass;
30 use templatable;
31 use tool_dataprivacy\data_registry;
33 require_once($CFG->libdir . '/coursecatlib.php');
34 require_once($CFG->dirroot . '/' . $CFG->admin . '/tool/dataprivacy/lib.php');
35 require_once($CFG->libdir . '/blocklib.php');
37 /**
38  * Class containing the data registry renderable
39  *
40  * @copyright  2018 David Monllao
41  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
42  */
43 class data_registry_page implements renderable, templatable {
45     /**
46      * @var int
47      */
48     private $defaultcontextlevel;
50     /**
51      * @var int
52      */
53     private $defaultcontextid;
55     /**
56      * Constructor.
57      *
58      * @param int $defaultcontextlevel
59      * @param int $defaultcontextid
60      * @return null
61      */
62     public function __construct($defaultcontextlevel = false, $defaultcontextid = false) {
63         $this->defaultcontextlevel = $defaultcontextlevel;
64         $this->defaultcontextid = $defaultcontextid;
65     }
67     /**
68      * Export this data so it can be used as the context for a mustache template.
69      *
70      * @param renderer_base $output
71      * @return stdClass
72      */
73     public function export_for_template(renderer_base $output) {
74         global $PAGE;
76         $params = [\context_system::instance()->id, $this->defaultcontextlevel, $this->defaultcontextid];
77         $PAGE->requires->js_call_amd('tool_dataprivacy/data_registry', 'init', $params);
79         $data = new stdClass();
80         $defaultsbutton = new \action_link(
81             new \moodle_url('/admin/tool/dataprivacy/defaults.php'),
82             get_string('setdefaults', 'tool_dataprivacy'),
83             null,
84             ['class' => 'btn btn-default']
85         );
86         $data->defaultsbutton = $defaultsbutton->export_for_template($output);
88         $actionmenu = new \action_menu();
89         $actionmenu->set_menu_trigger(get_string('edit'), 'btn btn-default');
90         $actionmenu->set_owner_selector('dataregistry-actions');
91         $actionmenu->set_alignment(\action_menu::TL, \action_menu::BL);
93         $url = new \moodle_url('/admin/tool/dataprivacy/categories.php');
94         $categories = new \action_menu_link_secondary($url, null, get_string('categories', 'tool_dataprivacy'));
95         $actionmenu->add($categories);
97         $url = new \moodle_url('/admin/tool/dataprivacy/purposes.php');
98         $purposes = new \action_menu_link_secondary($url, null, get_string('purposes', 'tool_dataprivacy'));
99         $actionmenu->add($purposes);
101         $data->actions = $actionmenu->export_for_template($output);
103         if (!data_registry::defaults_set()) {
104             $data->info = (object)[
105                     'message' => get_string('dataregistryinfo', 'tool_dataprivacy'),
106                     'announce' => 1
107             ];
108             $data->nosystemdefaults = (object)[
109                 'message' => get_string('nosystemdefaults', 'tool_dataprivacy'),
110                 'announce' => 1
111             ];
112         }
114         $data->tree = $this->get_default_tree_structure();
116         return $data;
117     }
119     /**
120      * Returns the tree default structure.
121      *
122      * @return array
123      */
124     private function get_default_tree_structure() {
126         $frontpage = \context_course::instance(SITEID);
128         $categorybranches = $this->get_all_category_branches();
130         $elements = [
131             'text' => get_string('contextlevelname' . CONTEXT_SYSTEM, 'tool_dataprivacy'),
132             'contextlevel' => CONTEXT_SYSTEM,
133             'branches' => [
134                 [
135                     'text' => get_string('user'),
136                     'contextlevel' => CONTEXT_USER,
137                 ], [
138                     'text' => get_string('categories'),
139                     'branches' => $categorybranches,
140                     'expandelement' => 'category',
141                 ], [
142                     'text' => get_string('frontpagecourse', 'tool_dataprivacy'),
143                     'contextid' => $frontpage->id,
144                     'branches' => [
145                         [
146                             'text' => get_string('activitiesandresources', 'tool_dataprivacy'),
147                             'expandcontextid' => $frontpage->id,
148                             'expandelement' => 'module',
149                             'expanded' => 0,
150                         ], [
151                             'text' => get_string('blocks'),
152                             'expandcontextid' => $frontpage->id,
153                             'expandelement' => 'block',
154                             'expanded' => 0,
155                         ],
156                     ]
157                 ]
158             ]
159         ];
161         // Returned as an array to follow a common array format.
162         return [self::complete($elements, $this->defaultcontextlevel, $this->defaultcontextid)];
163     }
165     /**
166      * Returns the hierarchy of system course categories.
167      *
168      * @return array
169      */
170     private function get_all_category_branches() {
172         $categories = data_registry::get_site_categories();
174         $categoriesbranch = [];
175         while (count($categories) > 0) {
176             foreach ($categories as $key => $category) {
178                 $context = \context_coursecat::instance($category->id);
179                 $newnode = [
180                     'text' => shorten_text(format_string($category->name, true, ['context' => $context])),
181                     'categoryid' => $category->id,
182                     'contextid' => $context->id,
183                 ];
184                 if ($category->coursecount > 0) {
185                     $newnode['branches'] = [
186                         [
187                             'text' => get_string('courses'),
188                             'expandcontextid' => $context->id,
189                             'expandelement' => 'course',
190                             'expanded' => 0,
191                         ]
192                     ];
193                 }
195                 $added = false;
196                 if ($category->parent == 0) {
197                     // New categories root-level node.
198                     $categoriesbranch[] = $newnode;
199                     $added = true;
201                 } else {
202                     // Add the new node under the appropriate parent.
203                     if ($this->add_to_parent_category_branch($category, $newnode, $categoriesbranch)) {
204                         $added = true;
205                     }
206                 }
208                 if ($added) {
209                     unset($categories[$key]);
210                 }
211             }
212         }
214         return $categoriesbranch;
215     }
217     /**
218      * Gets the courses branch for the provided category.
219      *
220      * @param \context $catcontext
221      * @return array
222      */
223     public static function get_courses_branch(\context $catcontext) {
225         if ($catcontext->contextlevel !== CONTEXT_COURSECAT) {
226             throw new \coding_exception('A course category context should be provided');
227         }
229         $coursecat = \coursecat::get($catcontext->instanceid);
230         $courses = $coursecat->get_courses();
232         $branches = [];
234         foreach ($courses as $course) {
236             $coursecontext = \context_course::instance($course->id);
238             if (!$course->visible && !has_capability('moodle/course:viewhiddencourses', $coursecontext)) {
239                 continue;
240             }
242             $coursenode = [
243                 'text' => shorten_text(format_string($course->shortname, true, ['context' => $coursecontext])),
244                 'contextid' => $coursecontext->id,
245                 'branches' => [
246                     [
247                         'text' => get_string('activitiesandresources', 'tool_dataprivacy'),
248                         'expandcontextid' => $coursecontext->id,
249                         'expandelement' => 'module',
250                         'expanded' => 0,
251                     ], [
252                         'text' => get_string('blocks'),
253                         'expandcontextid' => $coursecontext->id,
254                         'expandelement' => 'block',
255                         'expanded' => 0,
256                     ],
257                 ]
258             ];
259             $branches[] = self::complete($coursenode);
260         }
262         return $branches;
263     }
265     /**
266      * Gets the modules branch for the provided course.
267      *
268      * @param \context $coursecontext
269      * @return array
270      */
271     public static function get_modules_branch(\context $coursecontext) {
273         if ($coursecontext->contextlevel !== CONTEXT_COURSE) {
274             throw new \coding_exception('A course context should be provided');
275         }
277         $branches = [];
279         // Using the current user.
280         $modinfo = get_fast_modinfo($coursecontext->instanceid);
281         foreach ($modinfo->get_instances() as $moduletype => $instances) {
282             foreach ($instances as $cm) {
284                 if (!$cm->uservisible) {
285                     continue;
286                 }
288                 $a = (object)[
289                     'instancename' => shorten_text($cm->get_formatted_name()),
290                     'modulename' => get_string('pluginname', 'mod_' . $moduletype),
291                 ];
293                 $text = get_string('moduleinstancename', 'tool_dataprivacy', $a);
294                 $branches[] = self::complete([
295                     'text' => $text,
296                     'contextid' => $cm->context->id,
297                 ]);
298             }
299         }
301         return $branches;
302     }
304     /**
305      * Gets the blocks branch for the provided course.
306      *
307      * @param \context $coursecontext
308      * @return null
309      */
310     public static function get_blocks_branch(\context $coursecontext) {
311         global $DB;
313         if ($coursecontext->contextlevel !== CONTEXT_COURSE) {
314             throw new \coding_exception('A course context should be provided');
315         }
317         $branches = [];
319         $children = $coursecontext->get_child_contexts();
320         foreach ($children as $childcontext) {
322             if ($childcontext->contextlevel !== CONTEXT_BLOCK) {
323                 continue;
324             }
326             $blockinstance = block_instance_by_id($childcontext->instanceid);
327             $displayname = shorten_text(format_string($blockinstance->get_title(), true, ['context' => $childcontext]));
328             $branches[] = self::complete([
329                 'text' => $displayname,
330                 'contextid' => $childcontext->id,
331             ]);
333         }
335         return $branches;
336     }
338     /**
339      * Adds the provided category to the categories branch.
340      *
341      * @param stdClass $category
342      * @param array $newnode
343      * @param array $categoriesbranch
344      * @return bool
345      */
346     private function add_to_parent_category_branch($category, $newnode, &$categoriesbranch) {
348         foreach ($categoriesbranch as $key => $branch) {
349             if (!empty($branch['categoryid']) && $branch['categoryid'] == $category->parent) {
350                 // It may be empty (if it does not contain courses and this is the first child cat).
351                 if (!isset($categoriesbranch[$key]['branches'])) {
352                     $categoriesbranch[$key]['branches'] = [];
353                 }
354                 $categoriesbranch[$key]['branches'][] = $newnode;
355                 return true;
356             }
357             if (!empty($branch['branches'])) {
358                 $parent = $this->add_to_parent_category_branch($category, $newnode, $categoriesbranch[$key]['branches']);
359                 if ($parent) {
360                     return true;
361                 }
362             }
363         }
365         return false;
366     }
368     /**
369      * Completes tree nodes with default values.
370      *
371      * @param array $node
372      * @param int|false $currentcontextlevel
373      * @param int|false $currentcontextid
374      * @return array
375      */
376     private static function complete($node, $currentcontextlevel = false, $currentcontextid = false) {
377         if (!isset($node['active'])) {
378             if ($currentcontextlevel && !empty($node['contextlevel']) &&
379                     $currentcontextlevel == $node['contextlevel'] &&
380                     empty($currentcontextid)) {
381                 // This is the active context level, we also checked that there
382                 // is no default contextid set.
383                 $node['active'] = true;
384             } else if ($currentcontextid && !empty($node['contextid']) &&
385                     $currentcontextid == $node['contextid']) {
386                 $node['active'] = true;
387             } else {
388                 $node['active'] = null;
389             }
390         }
392         if (!isset($node['branches'])) {
393             $node['branches'] = [];
394         } else {
395             foreach ($node['branches'] as $key => $childnode) {
396                 $node['branches'][$key] = self::complete($childnode, $currentcontextlevel, $currentcontextid);
397             }
398         }
400         if (!isset($node['expandelement'])) {
401             $node['expandelement'] = null;
402         }
404         if (!isset($node['expandcontextid'])) {
405             $node['expandcontextid'] = null;
406         }
408         if (!isset($node['contextid'])) {
409             $node['contextid'] = null;
410         }
412         if (!isset($node['contextlevel'])) {
413             $node['contextlevel'] = null;
414         }
416         if (!isset($node['expanded'])) {
417             if (!empty($node['branches'])) {
418                 $node['expanded'] = 1;
419             } else {
420                 $node['expanded'] = 0;
421             }
422         }
423         return $node;
424     }
426     /**
427      * From a list of purpose persistents to a list of id => name purposes.
428      *
429      * @param \tool_dataprivacy\purpose $purposes
430      * @param bool $includenotset
431      * @param bool $includeinherit
432      * @return string[]
433      */
434     public static function purpose_options($purposes, $includenotset = true, $includeinherit = true) {
435         $options = self::base_options($includenotset, $includeinherit);
436         foreach ($purposes as $purpose) {
437             $options[$purpose->get('id')] = $purpose->get('name');
438         }
440         return $options;
441     }
443     /**
444      * From a list of category persistents to a list of id => name categories.
445      *
446      * @param \tool_dataprivacy\category $categories
447      * @param bool $includenotset
448      * @param bool $includeinherit
449      * @return string[]
450      */
451     public static function category_options($categories, $includenotset = true, $includeinherit = true) {
452         $options = self::base_options($includenotset, $includeinherit);
453         foreach ($categories as $category) {
454             $options[$category->get('id')] = $category->get('name');
455         }
457         return $options;
458     }
460     /**
461      * Base not set and inherit options.
462      *
463      * @param bool $includenotset
464      * @param bool $includeinherit
465      * @return array
466      */
467     private static function base_options($includenotset = true, $includeinherit = true) {
469         $options = [];
471         if ($includenotset) {
472             $options[\tool_dataprivacy\context_instance::NOTSET] = get_string('notset', 'tool_dataprivacy');
473         }
475         if ($includeinherit) {
476             $options[\tool_dataprivacy\context_instance::INHERIT] = get_string('inherit', 'tool_dataprivacy');
477         }
479         return $options;
480     }