MDL-63333 core: removed unused setting 'messaginghidereadnotifications'
[moodle.git] / admin / tool / dataprivacy / classes / data_registry.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 business logic methods. Mostly internal stuff.
19  *
20  * All methods should be considered part of the internal tool_dataprivacy API
21  * unless something different is specified.
22  *
23  * @package    tool_dataprivacy
24  * @copyright  2018 David Monllao
25  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
26  */
28 namespace tool_dataprivacy;
30 use coding_exception;
31 use tool_dataprivacy\purpose;
32 use tool_dataprivacy\category;
33 use tool_dataprivacy\contextlevel;
34 use tool_dataprivacy\context_instance;
36 defined('MOODLE_INTERNAL') || die();
38 /**
39  * Data registry business logic methods. Mostly internal stuff.
40  *
41  * @copyright  2018 David Monllao
42  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
43  */
44 class data_registry {
46     /**
47      * @var array Inheritance between context levels.
48      */
49     private static $contextlevelinheritance = [
50         CONTEXT_USER => [CONTEXT_SYSTEM],
51         CONTEXT_COURSECAT => [CONTEXT_SYSTEM],
52         CONTEXT_COURSE => [CONTEXT_COURSECAT, CONTEXT_SYSTEM],
53         CONTEXT_MODULE => [CONTEXT_COURSE, CONTEXT_COURSECAT, CONTEXT_SYSTEM],
54         CONTEXT_BLOCK => [CONTEXT_COURSE, CONTEXT_COURSECAT, CONTEXT_SYSTEM],
55     ];
57     /**
58      * Returns purpose and category var names from a context class name
59      *
60      * @param string $classname
61      * @return string[]
62      */
63     public static function var_names_from_context($classname) {
64         return [
65             $classname . '_purpose',
66             $classname . '_category',
67         ];
68     }
70     /**
71      * Returns the default purpose id and category id for the provided context level.
72      *
73      * The caller code is responsible of checking that $contextlevel is an integer.
74      *
75      * @param int $contextlevel
76      * @return int|false[]
77      */
78     public static function get_defaults($contextlevel) {
80         $classname = \context_helper::get_class_for_level($contextlevel);
81         list($purposevar, $categoryvar) = self::var_names_from_context($classname);
83         $purposeid = get_config('tool_dataprivacy', $purposevar);
84         $categoryid = get_config('tool_dataprivacy', $categoryvar);
86         if (empty($purposeid)) {
87             $purposeid = false;
88         }
89         if (empty($categoryid)) {
90             $categoryid = false;
91         }
93         return [$purposeid, $categoryid];
94     }
96     /**
97      * Are data registry defaults set?
98      *
99      * At least the system defaults need to be set.
100      *
101      * @return bool
102      */
103     public static function defaults_set() {
104         list($purposeid, $categoryid) = self::get_defaults(CONTEXT_SYSTEM);
105         if (empty($purposeid) || empty($categoryid)) {
106             return false;
107         }
108         return true;
109     }
111     /**
112      * Returns all site categories that are visible to the current user.
113      *
114      * @return \core_course_category[]
115      */
116     public static function get_site_categories() {
117         global $DB;
119         if (method_exists('\core_course_category', 'get_all')) {
120             $categories = \core_course_category::get_all(['returnhidden' => true]);
121         } else {
122             // Fallback (to be removed once this gets integrated into master).
123             $ids = $DB->get_fieldset_select('course_categories', 'id', '');
124             $categories = \core_course_category::get_many($ids);
125         }
127         foreach ($categories as $key => $category) {
128             if (!$category->is_uservisible()) {
129                 unset($categories[$key]);
130             }
131         }
132         return $categories;
133     }
135     /**
136      * Returns the roles assigned to the provided level.
137      *
138      * Important to note that it returns course-level assigned roles
139      * if the provided context level is below course.
140      *
141      * @param \context $context
142      * @return array
143      */
144     public static function get_subject_scope(\context $context) {
146         if ($contextcourse = $context->get_course_context(false)) {
147             // Below course level we look at module or block level roles + course-assigned roles.
148             $courseroles = get_roles_used_in_context($contextcourse, false);
149             $roles = $courseroles + get_roles_used_in_context($context, false);
150         } else {
151             // We list category + system for others (we don't work with user instances so no need to work about them).
152             $roles = get_roles_used_in_context($context);
153         }
155         return array_map(function($role) {
156             if ($role->name) {
157                 return $role->name;
158             } else {
159                 return $role->shortname;
160             }
161         }, $roles);
162     }
164     /**
165      * Returns the effective value given a context instance
166      *
167      * @param \context $context
168      * @param string $element 'category' or 'purpose'
169      * @param int|false $forcedvalue Use this value as if this was this context instance value.
170      * @return persistent|false It return a 'purpose' instance or a 'category' instance, depending on $element
171      */
172     public static function get_effective_context_value(\context $context, $element, $forcedvalue=false) {
174         if ($element !== 'purpose' && $element !== 'category') {
175             throw new coding_exception('Only \'purpose\' and \'category\' are supported.');
176         }
177         $fieldname = $element . 'id';
179         if ($forcedvalue === false) {
180             $instance = context_instance::get_record_by_contextid($context->id, false);
182             if (!$instance) {
183                 // If the instance does not have a value defaults to not set, so we grab the context level default as its value.
184                 $instancevalue = context_instance::NOTSET;
185             } else {
186                 $instancevalue = $instance->get($fieldname);
187             }
188         } else {
189             $instancevalue = $forcedvalue;
190         }
192         // Not set.
193         if ($instancevalue == context_instance::NOTSET) {
195             // The effective value varies depending on the context level.
196             if ($context->contextlevel == CONTEXT_USER) {
197                 // Use the context level value as we don't allow people to set specific instances values.
198                 return self::get_effective_contextlevel_value($context->contextlevel, $element);
199             } else {
200                 // Use the default context level value.
201                 list($purposeid, $categoryid) = self::get_effective_default_contextlevel_purpose_and_category(
202                     $context->contextlevel
203                 );
204                 return self::get_element_instance($element, $$fieldname);
205             }
206         }
208         // Specific value for this context instance.
209         if ($instancevalue != context_instance::INHERIT) {
210             return self::get_element_instance($element, $instancevalue);
211         }
213         // This context is using inherited so let's return the parent effective value.
214         $parentcontext = $context->get_parent_context();
215         if (!$parentcontext) {
216             return false;
217         }
219         // The forced value should not be transmitted to parent contexts.
220         return self::get_effective_context_value($parentcontext, $element);
221     }
223     /**
224      * Returns the effective value for a context level.
225      *
226      * Note that this is different from the effective default context level
227      * (see get_effective_default_contextlevel_purpose_and_category) as this is returning
228      * the value set in the data registry, not in the defaults page.
229      *
230      * @param int $contextlevel
231      * @param string $element 'category' or 'purpose'
232      * @param int $forcedvalue Use this value as if this was this context level purpose.
233      * @return \tool_dataprivacy\purpose|false
234      */
235     public static function get_effective_contextlevel_value($contextlevel, $element, $forcedvalue = false) {
237         if ($element !== 'purpose' && $element !== 'category') {
238             throw new coding_exception('Only \'purpose\' and \'category\' are supported.');
239         }
240         $fieldname = $element . 'id';
242         if ($contextlevel != CONTEXT_SYSTEM && $contextlevel != CONTEXT_USER) {
243             throw new \coding_exception('Only context_system and context_user values can be retrieved, no other context levels ' .
244                 'have a purpose or a category.');
245         }
247         if ($forcedvalue === false) {
248             $instance = contextlevel::get_record_by_contextlevel($contextlevel, false);
249             if (!$instance) {
250                 // If the context level does not have a value defaults to not set, so we grab the context level default as
251                 // its value.
252                 $instancevalue = context_instance::NOTSET;
253             } else {
254                 $instancevalue = $instance->get($fieldname);
255             }
256         } else {
257             $instancevalue = $forcedvalue;
258         }
260         // Not set -> Use the default context level value.
261         if ($instancevalue == context_instance::NOTSET) {
262             list($purposeid, $categoryid) = self::get_effective_default_contextlevel_purpose_and_category($contextlevel);
263             return self::get_element_instance($element, $$fieldname);
264         }
266         // Specific value for this context instance.
267         if ($instancevalue != context_instance::INHERIT) {
268             return self::get_element_instance($element, $instancevalue);
269         }
271         if ($contextlevel == CONTEXT_SYSTEM) {
272             throw new coding_exception('Something went wrong, system defaults should be set and we should already have a value.');
273         }
275         // If we reach this point is that we are inheriting so get the parent context level and repeat.
276         $parentcontextlevel = reset(self::$contextlevelinheritance[$contextlevel]);
278         // Forced value are intentionally not passed as the force value should only affect the immediate context level.
279         return self::get_effective_contextlevel_value($parentcontextlevel, $element);
280     }
282     /**
283      * Returns the effective default purpose and category for a context level.
284      *
285      * @param int $contextlevel
286      * @param int $forcedpurposevalue Use this value as if this was this context level purpose.
287      * @param int $forcedcategoryvalue Use this value as if this was this context level category.
288      * @return int[]
289      */
290     public static function get_effective_default_contextlevel_purpose_and_category($contextlevel, $forcedpurposevalue = false,
291                                                                                    $forcedcategoryvalue = false) {
293         list($purposeid, $categoryid) = self::get_defaults($contextlevel);
295         // Honour forced values.
296         if ($forcedpurposevalue) {
297             $purposeid = $forcedpurposevalue;
298         }
299         if ($forcedcategoryvalue) {
300             $categoryid = $forcedcategoryvalue;
301         }
303         // Not set == INHERIT for defaults.
304         if ($purposeid == context_instance::INHERIT || $purposeid == context_instance::NOTSET) {
305             $purposeid = false;
306         }
307         if ($categoryid == context_instance::INHERIT || $categoryid == context_instance::NOTSET) {
308             $categoryid = false;
309         }
311         if ($contextlevel != CONTEXT_SYSTEM && ($purposeid === false || $categoryid === false)) {
312             foreach (self::$contextlevelinheritance[$contextlevel] as $parent) {
314                 list($parentpurposeid, $parentcategoryid) = self::get_defaults($parent);
315                 // Not set == INHERIT for defaults.
316                 if ($parentpurposeid == context_instance::INHERIT || $parentpurposeid == context_instance::NOTSET) {
317                     $parentpurposeid = false;
318                 }
319                 if ($parentcategoryid == context_instance::INHERIT || $parentcategoryid == context_instance::NOTSET) {
320                     $parentcategoryid = false;
321                 }
323                 if ($purposeid === false && $parentpurposeid) {
324                     $purposeid = $parentpurposeid;
325                 }
327                 if ($categoryid === false && $parentcategoryid) {
328                     $categoryid = $parentcategoryid;
329                 }
330             }
331         }
333         // They may still be false, but we return anyway.
334         return [$purposeid, $categoryid];
335     }
337     /**
338      * Returns an instance of the provided element.
339      *
340      * @throws \coding_exception
341      * @param string $element The element name 'purpose' or 'category'
342      * @param int $id The element id
343      * @return \core\persistent
344      */
345     private static function get_element_instance($element, $id) {
347         if ($element !== 'purpose' && $element !== 'category') {
348             throw new coding_exception('No other elements than purpose and category are allowed');
349         }
351         $classname = '\tool_dataprivacy\\' . $element;
352         return new $classname($id);
353     }