MDL-63102 core_block: Reduced spacing between blocks
[moodle.git] / admin / tool / dataprivacy / classes / api.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  * Class containing helper methods for processing data requests.
19  *
20  * @package    tool_dataprivacy
21  * @copyright  2018 Jun Pataleta
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
24 namespace tool_dataprivacy;
26 use coding_exception;
27 use context_helper;
28 use context_system;
29 use core\invalid_persistent_exception;
30 use core\message\message;
31 use core\task\manager;
32 use core_privacy\local\request\approved_contextlist;
33 use core_privacy\local\request\contextlist_collection;
34 use core_user;
35 use dml_exception;
36 use moodle_exception;
37 use moodle_url;
38 use required_capability_exception;
39 use stdClass;
40 use tool_dataprivacy\external\data_request_exporter;
41 use tool_dataprivacy\local\helper;
42 use tool_dataprivacy\task\initiate_data_request_task;
43 use tool_dataprivacy\task\process_data_request_task;
45 defined('MOODLE_INTERNAL') || die();
47 /**
48  * Class containing helper methods for processing data requests.
49  *
50  * @copyright  2018 Jun Pataleta
51  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
52  */
53 class api {
55     /** Data export request type. */
56     const DATAREQUEST_TYPE_EXPORT = 1;
58     /** Data deletion request type. */
59     const DATAREQUEST_TYPE_DELETE = 2;
61     /** Other request type. Usually of enquiries to the DPO. */
62     const DATAREQUEST_TYPE_OTHERS = 3;
64     /** Newly submitted and we haven't yet started finding out where they have data. */
65     const DATAREQUEST_STATUS_PENDING = 0;
67     /** Newly submitted and we have started to find the location of data. */
68     const DATAREQUEST_STATUS_PREPROCESSING = 1;
70     /** Metadata ready and awaiting review and approval by the Data Protection officer. */
71     const DATAREQUEST_STATUS_AWAITING_APPROVAL = 2;
73     /** Request approved and will be processed soon. */
74     const DATAREQUEST_STATUS_APPROVED = 3;
76     /** The request is now being processed. */
77     const DATAREQUEST_STATUS_PROCESSING = 4;
79     /** Information/other request completed. */
80     const DATAREQUEST_STATUS_COMPLETE = 5;
82     /** Data request cancelled by the user. */
83     const DATAREQUEST_STATUS_CANCELLED = 6;
85     /** Data request rejected by the DPO. */
86     const DATAREQUEST_STATUS_REJECTED = 7;
88     /** Data request download ready. */
89     const DATAREQUEST_STATUS_DOWNLOAD_READY = 8;
91     /** Data request expired. */
92     const DATAREQUEST_STATUS_EXPIRED = 9;
94     /** Data delete request completed, account is removed. */
95     const DATAREQUEST_STATUS_DELETED = 10;
97     /** Approve data request. */
98     const DATAREQUEST_ACTION_APPROVE = 1;
100     /** Reject data request. */
101     const DATAREQUEST_ACTION_REJECT = 2;
103     /**
104      * Determines whether the user can contact the site's Data Protection Officer via Moodle.
105      *
106      * @return boolean True when tool_dataprivacy|contactdataprotectionofficer is enabled.
107      * @throws dml_exception
108      */
109     public static function can_contact_dpo() {
110         return get_config('tool_dataprivacy', 'contactdataprotectionofficer') == 1;
111     }
113     /**
114      * Checks whether the current user has the capability to manage data requests.
115      *
116      * @param int $userid The user ID.
117      * @return bool
118      */
119     public static function can_manage_data_requests($userid) {
120         // Privacy officers can manage data requests.
121         return self::is_site_dpo($userid);
122     }
124     /**
125      * Checks if the current user can manage the data registry at the provided id.
126      *
127      * @param int $contextid Fallback to system context id.
128      * @throws \required_capability_exception
129      * @return null
130      */
131     public static function check_can_manage_data_registry($contextid = false) {
132         if ($contextid) {
133             $context = \context_helper::instance_by_id($contextid);
134         } else {
135             $context = \context_system::instance();
136         }
138         require_capability('tool/dataprivacy:managedataregistry', $context);
139     }
141     /**
142      * Fetches the list of configured privacy officer roles.
143      *
144      * Every time this function is called, it checks each role if they have the 'managedatarequests' capability and removes
145      * any role that doesn't have the required capability anymore.
146      *
147      * @return int[]
148      * @throws dml_exception
149      */
150     public static function get_assigned_privacy_officer_roles() {
151         $roleids = [];
153         // Get roles from config.
154         $configroleids = explode(',', str_replace(' ', '', get_config('tool_dataprivacy', 'dporoles')));
155         if (!empty($configroleids)) {
156             // Fetch roles that have the capability to manage data requests.
157             $capableroles = array_keys(get_roles_with_capability('tool/dataprivacy:managedatarequests'));
159             // Extract the configured roles that have the capability from the list of capable roles.
160             $roleids = array_intersect($capableroles, $configroleids);
161         }
163         return $roleids;
164     }
166     /**
167      * Fetches the role shortnames of Data Protection Officer roles.
168      *
169      * @return array An array of the DPO role shortnames
170      */
171     public static function get_dpo_role_names() : array {
172         global $DB;
174         $dporoleids = self::get_assigned_privacy_officer_roles();
175         $dponames = array();
177         if (!empty($dporoleids)) {
178             list($insql, $inparams) = $DB->get_in_or_equal($dporoleids);
179             $dponames = $DB->get_fieldset_select('role', 'shortname', "id {$insql}", $inparams);
180         }
182         return $dponames;
183     }
185     /**
186      * Fetches the list of users with the Privacy Officer role.
187      */
188     public static function get_site_dpos() {
189         // Get role(s) that can manage data requests.
190         $dporoles = self::get_assigned_privacy_officer_roles();
192         $dpos = [];
193         $context = context_system::instance();
194         foreach ($dporoles as $roleid) {
195             $allnames = get_all_user_name_fields(true, 'u');
196             $fields = 'u.id, u.confirmed, u.username, '. $allnames . ', ' .
197                       'u.maildisplay, u.mailformat, u.maildigest, u.email, u.emailstop, u.city, '.
198                       'u.country, u.picture, u.idnumber, u.department, u.institution, '.
199                       'u.lang, u.timezone, u.lastaccess, u.mnethostid, u.auth, u.suspended, u.deleted, ' .
200                       'r.name AS rolename, r.sortorder, '.
201                       'r.shortname AS roleshortname, rn.name AS rolecoursealias';
202             // Fetch users that can manage data requests.
203             $dpos += get_role_users($roleid, $context, false, $fields);
204         }
206         // If the site has no data protection officer, defer to site admin(s).
207         if (empty($dpos)) {
208             $dpos = get_admins();
209         }
210         return $dpos;
211     }
213     /**
214      * Checks whether a given user is a site Privacy Officer.
215      *
216      * @param int $userid The user ID.
217      * @return bool
218      */
219     public static function is_site_dpo($userid) {
220         $dpos = self::get_site_dpos();
221         return array_key_exists($userid, $dpos) || is_siteadmin();
222     }
224     /**
225      * Lodges a data request and sends the request details to the site Data Protection Officer(s).
226      *
227      * @param int $foruser The user whom the request is being made for.
228      * @param int $type The request type.
229      * @param string $comments Request comments.
230      * @return data_request
231      * @throws invalid_persistent_exception
232      * @throws coding_exception
233      */
234     public static function create_data_request($foruser, $type, $comments = '') {
235         global $USER;
237         $datarequest = new data_request();
238         // The user the request is being made for.
239         $datarequest->set('userid', $foruser);
241         $requestinguser = $USER->id;
242         // Check when the user is making a request on behalf of another.
243         if ($requestinguser != $foruser) {
244             if (self::is_site_dpo($requestinguser)) {
245                 // The user making the request is a DPO. Should be fine.
246                 $datarequest->set('dpo', $requestinguser);
247             } else {
248                 // If not a DPO, only users with the capability to make data requests for the user should be allowed.
249                 // (e.g. users with the Parent role, etc).
250                 if (!self::can_create_data_request_for_user($foruser)) {
251                     $forusercontext = \context_user::instance($foruser);
252                     throw new required_capability_exception($forusercontext,
253                             'tool/dataprivacy:makedatarequestsforchildren', 'nopermissions', '');
254                 }
255             }
256         }
257         // The user making the request.
258         $datarequest->set('requestedby', $requestinguser);
259         // Set status.
260         $datarequest->set('status', self::DATAREQUEST_STATUS_PENDING);
261         // Set request type.
262         $datarequest->set('type', $type);
263         // Set request comments.
264         $datarequest->set('comments', $comments);
266         // Store subject access request.
267         $datarequest->create();
269         // Fire an ad hoc task to initiate the data request process.
270         $task = new initiate_data_request_task();
271         $task->set_custom_data(['requestid' => $datarequest->get('id')]);
272         manager::queue_adhoc_task($task, true);
274         return $datarequest;
275     }
277     /**
278      * Fetches the list of the data requests.
279      *
280      * If user ID is provided, it fetches the data requests for the user.
281      * Otherwise, it fetches all of the data requests, provided that the user has the capability to manage data requests.
282      * (e.g. Users with the Data Protection Officer roles)
283      *
284      * @param int $userid The User ID.
285      * @param int[] $statuses The status filters.
286      * @param int[] $types The request type filters.
287      * @param string $sort The order by clause.
288      * @param int $offset Amount of records to skip.
289      * @param int $limit Amount of records to fetch.
290      * @return data_request[]
291      * @throws coding_exception
292      * @throws dml_exception
293      */
294     public static function get_data_requests($userid = 0, $statuses = [], $types = [], $sort = '', $offset = 0, $limit = 0) {
295         global $DB, $USER;
296         $results = [];
297         $sqlparams = [];
298         $sqlconditions = [];
300         // Set default sort.
301         if (empty($sort)) {
302             $sort = 'status ASC, timemodified ASC';
303         }
305         // Set status filters.
306         if (!empty($statuses)) {
307             list($statusinsql, $sqlparams) = $DB->get_in_or_equal($statuses, SQL_PARAMS_NAMED);
308             $sqlconditions[] = "status $statusinsql";
309         }
311         // Set request type filter.
312         if (!empty($types)) {
313             list($typeinsql, $typeparams) = $DB->get_in_or_equal($types, SQL_PARAMS_NAMED);
314             $sqlconditions[] = "type $typeinsql";
315             $sqlparams = array_merge($sqlparams, $typeparams);
316         }
318         if ($userid) {
319             // Get the data requests for the user or data requests made by the user.
320             $sqlconditions[] = "(userid = :userid OR requestedby = :requestedby)";
321             $params = [
322                 'userid' => $userid,
323                 'requestedby' => $userid
324             ];
326             // Build a list of user IDs that the user is allowed to make data requests for.
327             // Of course, the user should be included in this list.
328             $alloweduserids = [$userid];
329             // Get any users that the user can make data requests for.
330             if ($children = helper::get_children_of_user($userid)) {
331                 // Get the list of user IDs of the children and merge to the allowed user IDs.
332                 $alloweduserids = array_merge($alloweduserids, array_keys($children));
333             }
334             list($insql, $inparams) = $DB->get_in_or_equal($alloweduserids, SQL_PARAMS_NAMED);
335             $sqlconditions[] .= "userid $insql";
336             $select = implode(' AND ', $sqlconditions);
337             $params = array_merge($params, $inparams, $sqlparams);
339             $results = data_request::get_records_select($select, $params, $sort, '*', $offset, $limit);
340         } else {
341             // If the current user is one of the site's Data Protection Officers, then fetch all data requests.
342             if (self::is_site_dpo($USER->id)) {
343                 if (!empty($sqlconditions)) {
344                     $select = implode(' AND ', $sqlconditions);
345                     $results = data_request::get_records_select($select, $sqlparams, $sort, '*', $offset, $limit);
346                 } else {
347                     $results = data_request::get_records(null, $sort, '', $offset, $limit);
348                 }
349             }
350         }
352         // If any are due to expire, expire them and re-fetch updated data.
353         if (empty($statuses)
354                 || in_array(self::DATAREQUEST_STATUS_DOWNLOAD_READY, $statuses)
355                 || in_array(self::DATAREQUEST_STATUS_EXPIRED, $statuses)) {
356             $expiredrequests = data_request::get_expired_requests($userid);
358             if (!empty($expiredrequests)) {
359                 data_request::expire($expiredrequests);
360                 $results = self::get_data_requests($userid, $statuses, $types, $sort, $offset, $limit);
361             }
362         }
364         return $results;
365     }
367     /**
368      * Fetches the count of data request records based on the given parameters.
369      *
370      * @param int $userid The User ID.
371      * @param int[] $statuses The status filters.
372      * @param int[] $types The request type filters.
373      * @return int
374      * @throws coding_exception
375      * @throws dml_exception
376      */
377     public static function get_data_requests_count($userid = 0, $statuses = [], $types = []) {
378         global $DB, $USER;
379         $count = 0;
380         $sqlparams = [];
381         $sqlconditions = [];
382         if (!empty($statuses)) {
383             list($statusinsql, $sqlparams) = $DB->get_in_or_equal($statuses, SQL_PARAMS_NAMED);
384             $sqlconditions[] = "status $statusinsql";
385         }
386         if (!empty($types)) {
387             list($typeinsql, $typeparams) = $DB->get_in_or_equal($types, SQL_PARAMS_NAMED);
388             $sqlconditions[] = "type $typeinsql";
389             $sqlparams = array_merge($sqlparams, $typeparams);
390         }
391         if ($userid) {
392             // Get the data requests for the user or data requests made by the user.
393             $sqlconditions[] = "(userid = :userid OR requestedby = :requestedby)";
394             $params = [
395                 'userid' => $userid,
396                 'requestedby' => $userid
397             ];
399             // Build a list of user IDs that the user is allowed to make data requests for.
400             // Of course, the user should be included in this list.
401             $alloweduserids = [$userid];
402             // Get any users that the user can make data requests for.
403             if ($children = helper::get_children_of_user($userid)) {
404                 // Get the list of user IDs of the children and merge to the allowed user IDs.
405                 $alloweduserids = array_merge($alloweduserids, array_keys($children));
406             }
407             list($insql, $inparams) = $DB->get_in_or_equal($alloweduserids, SQL_PARAMS_NAMED);
408             $sqlconditions[] .= "userid $insql";
409             $select = implode(' AND ', $sqlconditions);
410             $params = array_merge($params, $inparams, $sqlparams);
412             $count = data_request::count_records_select($select, $params);
413         } else {
414             // If the current user is one of the site's Data Protection Officers, then fetch all data requests.
415             if (self::is_site_dpo($USER->id)) {
416                 if (!empty($sqlconditions)) {
417                     $select = implode(' AND ', $sqlconditions);
418                     $count = data_request::count_records_select($select, $sqlparams);
419                 } else {
420                     $count = data_request::count_records();
421                 }
422             }
423         }
425         return $count;
426     }
428     /**
429      * Checks whether there is already an existing pending/in-progress data request for a user for a given request type.
430      *
431      * @param int $userid The user ID.
432      * @param int $type The request type.
433      * @return bool
434      * @throws coding_exception
435      * @throws dml_exception
436      */
437     public static function has_ongoing_request($userid, $type) {
438         global $DB;
440         // Check if the user already has an incomplete data request of the same type.
441         $nonpendingstatuses = [
442             self::DATAREQUEST_STATUS_COMPLETE,
443             self::DATAREQUEST_STATUS_CANCELLED,
444             self::DATAREQUEST_STATUS_REJECTED,
445             self::DATAREQUEST_STATUS_DOWNLOAD_READY,
446             self::DATAREQUEST_STATUS_EXPIRED,
447             self::DATAREQUEST_STATUS_DELETED,
448         ];
449         list($insql, $inparams) = $DB->get_in_or_equal($nonpendingstatuses, SQL_PARAMS_NAMED);
450         $select = 'type = :type AND userid = :userid AND status NOT ' . $insql;
451         $params = array_merge([
452             'type' => $type,
453             'userid' => $userid
454         ], $inparams);
456         return data_request::record_exists_select($select, $params);
457     }
459     /**
460      * Determines whether a request is active or not based on its status.
461      *
462      * @param int $status The request status.
463      * @return bool
464      */
465     public static function is_active($status) {
466         // List of statuses which doesn't require any further processing.
467         $finalstatuses = [
468             self::DATAREQUEST_STATUS_COMPLETE,
469             self::DATAREQUEST_STATUS_CANCELLED,
470             self::DATAREQUEST_STATUS_REJECTED,
471             self::DATAREQUEST_STATUS_DOWNLOAD_READY,
472             self::DATAREQUEST_STATUS_EXPIRED,
473             self::DATAREQUEST_STATUS_DELETED,
474         ];
476         return !in_array($status, $finalstatuses);
477     }
479     /**
480      * Cancels the data request for a given request ID.
481      *
482      * @param int $requestid The request identifier.
483      * @param int $status The request status.
484      * @param int $dpoid The user ID of the Data Protection Officer
485      * @param string $comment The comment about the status update.
486      * @return bool
487      * @throws invalid_persistent_exception
488      * @throws coding_exception
489      */
490     public static function update_request_status($requestid, $status, $dpoid = 0, $comment = '') {
491         // Update the request.
492         $datarequest = new data_request($requestid);
493         $datarequest->set('status', $status);
494         if ($dpoid) {
495             $datarequest->set('dpo', $dpoid);
496         }
497         // Update the comment if necessary.
498         if (!empty(trim($comment))) {
499             $params = [
500                 'date' => userdate(time()),
501                 'comment' => $comment
502             ];
503             $commenttosave = get_string('datecomment', 'tool_dataprivacy', $params);
504             // Check if there's an existing DPO comment.
505             $currentcomment = trim($datarequest->get('dpocomment'));
506             if ($currentcomment) {
507                 // Append the new comment to the current comment and give them 1 line space in between.
508                 $commenttosave = $currentcomment . PHP_EOL . PHP_EOL . $commenttosave;
509             }
510             $datarequest->set('dpocomment', $commenttosave);
511         }
513         return $datarequest->update();
514     }
516     /**
517      * Fetches a request based on the request ID.
518      *
519      * @param int $requestid The request identifier
520      * @return data_request
521      */
522     public static function get_request($requestid) {
523         return new data_request($requestid);
524     }
526     /**
527      * Approves a data request based on the request ID.
528      *
529      * @param int $requestid The request identifier
530      * @return bool
531      * @throws coding_exception
532      * @throws dml_exception
533      * @throws invalid_persistent_exception
534      * @throws required_capability_exception
535      * @throws moodle_exception
536      */
537     public static function approve_data_request($requestid) {
538         global $USER;
540         // Check first whether the user can manage data requests.
541         if (!self::can_manage_data_requests($USER->id)) {
542             $context = context_system::instance();
543             throw new required_capability_exception($context, 'tool/dataprivacy:managedatarequests', 'nopermissions', '');
544         }
546         // Check if request is already awaiting for approval.
547         $request = new data_request($requestid);
548         if ($request->get('status') != self::DATAREQUEST_STATUS_AWAITING_APPROVAL) {
549             throw new moodle_exception('errorrequestnotwaitingforapproval', 'tool_dataprivacy');
550         }
552         // Update the status and the DPO.
553         $result = self::update_request_status($requestid, self::DATAREQUEST_STATUS_APPROVED, $USER->id);
555         // Approve all the contexts attached to the request.
556         // Currently, approving the request implicitly approves all associated contexts, but this may change in future, allowing
557         // users to selectively approve certain contexts only.
558         self::update_request_contexts_with_status($requestid, contextlist_context::STATUS_APPROVED);
560         // Fire an ad hoc task to initiate the data request process.
561         $task = new process_data_request_task();
562         $task->set_custom_data(['requestid' => $requestid]);
563         if ($request->get('type') == self::DATAREQUEST_TYPE_EXPORT) {
564             $task->set_userid($request->get('userid'));
565         }
566         manager::queue_adhoc_task($task, true);
568         return $result;
569     }
571     /**
572      * Rejects a data request based on the request ID.
573      *
574      * @param int $requestid The request identifier
575      * @return bool
576      * @throws coding_exception
577      * @throws dml_exception
578      * @throws invalid_persistent_exception
579      * @throws required_capability_exception
580      * @throws moodle_exception
581      */
582     public static function deny_data_request($requestid) {
583         global $USER;
585         if (!self::can_manage_data_requests($USER->id)) {
586             $context = context_system::instance();
587             throw new required_capability_exception($context, 'tool/dataprivacy:managedatarequests', 'nopermissions', '');
588         }
590         // Check if request is already awaiting for approval.
591         $request = new data_request($requestid);
592         if ($request->get('status') != self::DATAREQUEST_STATUS_AWAITING_APPROVAL) {
593             throw new moodle_exception('errorrequestnotwaitingforapproval', 'tool_dataprivacy');
594         }
596         // Update the status and the DPO.
597         return self::update_request_status($requestid, self::DATAREQUEST_STATUS_REJECTED, $USER->id);
598     }
600     /**
601      * Sends a message to the site's Data Protection Officer about a request.
602      *
603      * @param stdClass $dpo The DPO user record
604      * @param data_request $request The data request
605      * @return int|false
606      * @throws coding_exception
607      * @throws moodle_exception
608      */
609     public static function notify_dpo($dpo, data_request $request) {
610         global $PAGE, $SITE;
612         $output = $PAGE->get_renderer('tool_dataprivacy');
614         $usercontext = \context_user::instance($request->get('requestedby'));
615         $requestexporter = new data_request_exporter($request, ['context' => $usercontext]);
616         $requestdata = $requestexporter->export($output);
618         // Create message to send to the Data Protection Officer(s).
619         $typetext = null;
620         $typetext = $requestdata->typename;
621         $subject = get_string('datarequestemailsubject', 'tool_dataprivacy', $typetext);
623         $requestedby = $requestdata->requestedbyuser;
624         $datarequestsurl = new moodle_url('/admin/tool/dataprivacy/datarequests.php');
625         $message = new message();
626         $message->courseid          = $SITE->id;
627         $message->component         = 'tool_dataprivacy';
628         $message->name              = 'contactdataprotectionofficer';
629         $message->userfrom          = $requestedby->id;
630         $message->replyto           = $requestedby->email;
631         $message->replytoname       = $requestedby->fullname;
632         $message->subject           = $subject;
633         $message->fullmessageformat = FORMAT_HTML;
634         $message->notification      = 1;
635         $message->contexturl        = $datarequestsurl;
636         $message->contexturlname    = get_string('datarequests', 'tool_dataprivacy');
638         // Prepare the context data for the email message body.
639         $messagetextdata = [
640             'requestedby' => $requestedby->fullname,
641             'requesttype' => $typetext,
642             'requestdate' => userdate($requestdata->timecreated),
643             'requestorigin' => $SITE->fullname,
644             'requestoriginurl' => new moodle_url('/'),
645             'requestcomments' => $requestdata->messagehtml,
646             'datarequestsurl' => $datarequestsurl
647         ];
648         $requestingfor = $requestdata->foruser;
649         if ($requestedby->id == $requestingfor->id) {
650             $messagetextdata['requestfor'] = $messagetextdata['requestedby'];
651         } else {
652             $messagetextdata['requestfor'] = $requestingfor->fullname;
653         }
655         // Email the data request to the Data Protection Officer(s)/Admin(s).
656         $messagetextdata['dponame'] = fullname($dpo);
657         // Render message email body.
658         $messagehtml = $output->render_from_template('tool_dataprivacy/data_request_email', $messagetextdata);
659         $message->userto = $dpo;
660         $message->fullmessage = html_to_text($messagehtml);
661         $message->fullmessagehtml = $messagehtml;
663         // Send message.
664         return message_send($message);
665     }
667     /**
668      * Checks whether a non-DPO user can make a data request for another user.
669      *
670      * @param int $user The user ID of the target user.
671      * @param int $requester The user ID of the user making the request.
672      * @return bool
673      * @throws coding_exception
674      */
675     public static function can_create_data_request_for_user($user, $requester = null) {
676         $usercontext = \context_user::instance($user);
677         return has_capability('tool/dataprivacy:makedatarequestsforchildren', $usercontext, $requester);
678     }
680     /**
681      * Checks whether a user can download a data request.
682      *
683      * @param int $userid Target user id (subject of data request)
684      * @param int $requesterid Requester user id (person who requsted it)
685      * @param int|null $downloaderid Person who wants to download user id (default current)
686      * @return bool
687      * @throws coding_exception
688      */
689     public static function can_download_data_request_for_user($userid, $requesterid, $downloaderid = null) {
690         global $USER;
692         if (!$downloaderid) {
693             $downloaderid = $USER->id;
694         }
696         $usercontext = \context_user::instance($userid);
697         // If it's your own and you have the right capability, you can download it.
698         if ($userid == $downloaderid && has_capability('tool/dataprivacy:downloadownrequest', $usercontext, $downloaderid)) {
699             return true;
700         }
701         // If you can download anyone's in that context, you can download it.
702         if (has_capability('tool/dataprivacy:downloadallrequests', $usercontext, $downloaderid)) {
703             return true;
704         }
705         // If you can have the 'child access' ability to request in that context, and you are the one
706         // who requested it, then you can download it.
707         if ($requesterid == $downloaderid && self::can_create_data_request_for_user($userid, $requesterid)) {
708             return true;
709         }
710         return false;
711     }
713     /**
714      * Gets an action menu link to download a data request.
715      *
716      * @param \context_user $usercontext User context (of user who the data is for)
717      * @param int $requestid Request id
718      * @return \action_menu_link_secondary Action menu link
719      * @throws coding_exception
720      */
721     public static function get_download_link(\context_user $usercontext, $requestid) {
722         $downloadurl = moodle_url::make_pluginfile_url($usercontext->id,
723                 'tool_dataprivacy', 'export', $requestid, '/', 'export.zip', true);
724         $downloadtext = get_string('download', 'tool_dataprivacy');
725         return new \action_menu_link_secondary($downloadurl, null, $downloadtext);
726     }
728     /**
729      * Creates a new data purpose.
730      *
731      * @param stdClass $record
732      * @return \tool_dataprivacy\purpose.
733      */
734     public static function create_purpose(stdClass $record) {
735         self::check_can_manage_data_registry();
737         $purpose = new purpose(0, $record);
738         $purpose->create();
740         return $purpose;
741     }
743     /**
744      * Updates an existing data purpose.
745      *
746      * @param stdClass $record
747      * @return \tool_dataprivacy\purpose.
748      */
749     public static function update_purpose(stdClass $record) {
750         self::check_can_manage_data_registry();
752         if (!isset($record->sensitivedatareasons)) {
753             $record->sensitivedatareasons = '';
754         }
756         $purpose = new purpose($record->id);
757         $purpose->from_record($record);
759         $result = $purpose->update();
761         return $purpose;
762     }
764     /**
765      * Deletes a data purpose.
766      *
767      * @param int $id
768      * @return bool
769      */
770     public static function delete_purpose($id) {
771         self::check_can_manage_data_registry();
773         $purpose = new purpose($id);
774         if ($purpose->is_used()) {
775             throw new \moodle_exception('Purpose with id ' . $id . ' can not be deleted because it is used.');
776         }
777         return $purpose->delete();
778     }
780     /**
781      * Get all system data purposes.
782      *
783      * @return \tool_dataprivacy\purpose[]
784      */
785     public static function get_purposes() {
786         self::check_can_manage_data_registry();
788         return purpose::get_records([], 'name', 'ASC');
789     }
791     /**
792      * Creates a new data category.
793      *
794      * @param stdClass $record
795      * @return \tool_dataprivacy\category.
796      */
797     public static function create_category(stdClass $record) {
798         self::check_can_manage_data_registry();
800         $category = new category(0, $record);
801         $category->create();
803         return $category;
804     }
806     /**
807      * Updates an existing data category.
808      *
809      * @param stdClass $record
810      * @return \tool_dataprivacy\category.
811      */
812     public static function update_category(stdClass $record) {
813         self::check_can_manage_data_registry();
815         $category = new category($record->id);
816         $category->from_record($record);
818         $result = $category->update();
820         return $category;
821     }
823     /**
824      * Deletes a data category.
825      *
826      * @param int $id
827      * @return bool
828      */
829     public static function delete_category($id) {
830         self::check_can_manage_data_registry();
832         $category = new category($id);
833         if ($category->is_used()) {
834             throw new \moodle_exception('Category with id ' . $id . ' can not be deleted because it is used.');
835         }
836         return $category->delete();
837     }
839     /**
840      * Get all system data categories.
841      *
842      * @return \tool_dataprivacy\category[]
843      */
844     public static function get_categories() {
845         self::check_can_manage_data_registry();
847         return category::get_records([], 'name', 'ASC');
848     }
850     /**
851      * Sets the context instance purpose and category.
852      *
853      * @param \stdClass $record
854      * @return \tool_dataprivacy\context_instance
855      */
856     public static function set_context_instance($record) {
857         self::check_can_manage_data_registry($record->contextid);
859         if ($instance = context_instance::get_record_by_contextid($record->contextid, false)) {
860             // Update.
861             $instance->from_record($record);
863             if (empty($record->purposeid) && empty($record->categoryid)) {
864                 // We accept one of them to be null but we delete it if both are null.
865                 self::unset_context_instance($instance);
866                 return;
867             }
869         } else {
870             // Add.
871             $instance = new context_instance(0, $record);
872         }
873         $instance->save();
875         return $instance;
876     }
878     /**
879      * Unsets the context instance record.
880      *
881      * @param \tool_dataprivacy\context_instance $instance
882      * @return null
883      */
884     public static function unset_context_instance(context_instance $instance) {
885         self::check_can_manage_data_registry($instance->get('contextid'));
886         $instance->delete();
887     }
889     /**
890      * Sets the context level purpose and category.
891      *
892      * @throws \coding_exception
893      * @param \stdClass $record
894      * @return contextlevel
895      */
896     public static function set_contextlevel($record) {
897         global $DB;
899         // Only manager at system level can set this.
900         self::check_can_manage_data_registry();
902         if ($record->contextlevel != CONTEXT_SYSTEM && $record->contextlevel != CONTEXT_USER) {
903             throw new \coding_exception('Only context system and context user can set a contextlevel ' .
904                 'purpose and retention');
905         }
907         if ($contextlevel = contextlevel::get_record_by_contextlevel($record->contextlevel, false)) {
908             // Update.
909             $contextlevel->from_record($record);
910         } else {
911             // Add.
912             $contextlevel = new contextlevel(0, $record);
913         }
914         $contextlevel->save();
916         // We sync with their defaults as we removed these options from the defaults page.
917         $classname = \context_helper::get_class_for_level($record->contextlevel);
918         list($purposevar, $categoryvar) = data_registry::var_names_from_context($classname);
919         set_config($purposevar, $record->purposeid, 'tool_dataprivacy');
920         set_config($categoryvar, $record->categoryid, 'tool_dataprivacy');
922         return $contextlevel;
923     }
925     /**
926      * Returns the effective category given a context instance.
927      *
928      * @param \context $context
929      * @param int $forcedvalue Use this categoryid value as if this was this context instance category.
930      * @return category|false
931      */
932     public static function get_effective_context_category(\context $context, $forcedvalue=false) {
933         self::check_can_manage_data_registry($context->id);
934         if (!data_registry::defaults_set()) {
935             return false;
936         }
938         return data_registry::get_effective_context_value($context, 'category', $forcedvalue);
939     }
941     /**
942      * Returns the effective purpose given a context instance.
943      *
944      * @param \context $context
945      * @param int $forcedvalue Use this purposeid value as if this was this context instance purpose.
946      * @return purpose|false
947      */
948     public static function get_effective_context_purpose(\context $context, $forcedvalue=false) {
949         self::check_can_manage_data_registry($context->id);
950         if (!data_registry::defaults_set()) {
951             return false;
952         }
954         return data_registry::get_effective_context_value($context, 'purpose', $forcedvalue);
955     }
957     /**
958      * Returns the effective category given a context level.
959      *
960      * @param int $contextlevel
961      * @param int $forcedvalue Use this categoryid value as if this was this context level category.
962      * @return category|false
963      */
964     public static function get_effective_contextlevel_category($contextlevel, $forcedvalue=false) {
965         self::check_can_manage_data_registry(\context_system::instance()->id);
966         if (!data_registry::defaults_set()) {
967             return false;
968         }
970         return data_registry::get_effective_contextlevel_value($contextlevel, 'category', $forcedvalue);
971     }
973     /**
974      * Returns the effective purpose given a context level.
975      *
976      * @param int $contextlevel
977      * @param int $forcedvalue Use this purposeid value as if this was this context level purpose.
978      * @return purpose|false
979      */
980     public static function get_effective_contextlevel_purpose($contextlevel, $forcedvalue=false) {
981         self::check_can_manage_data_registry(\context_system::instance()->id);
982         if (!data_registry::defaults_set()) {
983             return false;
984         }
986         return data_registry::get_effective_contextlevel_value($contextlevel, 'purpose', $forcedvalue);
987     }
989     /**
990      * Creates an expired context record for the provided context id.
991      *
992      * @param int $contextid
993      * @return \tool_dataprivacy\expired_context
994      */
995     public static function create_expired_context($contextid) {
996         self::check_can_manage_data_registry();
998         $record = (object)[
999             'contextid' => $contextid,
1000             'status' => expired_context::STATUS_EXPIRED,
1001         ];
1002         $expiredctx = new expired_context(0, $record);
1003         $expiredctx->save();
1005         return $expiredctx;
1006     }
1008     /**
1009      * Deletes an expired context record.
1010      *
1011      * @param int $id The tool_dataprivacy_ctxexpire id.
1012      * @return bool True on success.
1013      */
1014     public static function delete_expired_context($id) {
1015         self::check_can_manage_data_registry();
1017         $expiredcontext = new expired_context($id);
1018         return $expiredcontext->delete();
1019     }
1021     /**
1022      * Updates the status of an expired context.
1023      *
1024      * @param \tool_dataprivacy\expired_context $expiredctx
1025      * @param int $status
1026      * @return null
1027      */
1028     public static function set_expired_context_status(expired_context $expiredctx, $status) {
1029         self::check_can_manage_data_registry();
1031         $expiredctx->set('status', $status);
1032         $expiredctx->save();
1033     }
1035     /**
1036      * Adds the contexts from the contextlist_collection to the request with the status provided.
1037      *
1038      * @param contextlist_collection $clcollection a collection of contextlists for all components.
1039      * @param int $requestid the id of the request.
1040      * @param int $status the status to set the contexts to.
1041      */
1042     public static function add_request_contexts_with_status(contextlist_collection $clcollection, int $requestid, int $status) {
1043         $request = new data_request($requestid);
1044         foreach ($clcollection as $contextlist) {
1045             // Convert the \core_privacy\local\request\contextlist into a contextlist persistent and store it.
1046             $clp = \tool_dataprivacy\contextlist::from_contextlist($contextlist);
1047             $clp->create();
1048             $contextlistid = $clp->get('id');
1050             // Store the associated contexts in the contextlist.
1051             foreach ($contextlist->get_contextids() as $contextid) {
1052                 if ($request->get('type') == static::DATAREQUEST_TYPE_DELETE) {
1053                     $context = \context::instance_by_id($contextid);
1054                     if (($purpose = static::get_effective_context_purpose($context)) && !empty($purpose->get('protected'))) {
1055                         continue;
1056                     }
1057                 }
1058                 $context = new contextlist_context();
1059                 $context->set('contextid', $contextid)
1060                     ->set('contextlistid', $contextlistid)
1061                     ->set('status', $status)
1062                     ->create();
1063             }
1065             // Create the relation to the request.
1066             $requestcontextlist = request_contextlist::create_relation($requestid, $contextlistid);
1067             $requestcontextlist->create();
1068         }
1069     }
1071     /**
1072      * Sets the status of all contexts associated with the request.
1073      *
1074      * @param int $requestid the requestid to which the contexts belong.
1075      * @param int $status the status to set to.
1076      * @throws \dml_exception if the requestid is invalid.
1077      * @throws \moodle_exception if the status is invalid.
1078      */
1079     public static function update_request_contexts_with_status(int $requestid, int $status) {
1080         // Validate contextlist_context status using the persistent's attribute validation.
1081         $contextlistcontext = new contextlist_context();
1082         $contextlistcontext->set('status', $status);
1083         if (array_key_exists('status', $contextlistcontext->get_errors())) {
1084             throw new moodle_exception("Invalid contextlist_context status: $status");
1085         }
1087         // Validate requestid using the persistent's record validation.
1088         // A dml_exception is thrown if the record is missing.
1089         $datarequest = new data_request($requestid);
1091         // Bulk update the status of the request contexts.
1092         global $DB;
1094         $select = "SELECT ctx.id as id
1095                      FROM {" . request_contextlist::TABLE . "} rcl
1096                      JOIN {" . contextlist::TABLE . "} cl ON rcl.contextlistid = cl.id
1097                      JOIN {" . contextlist_context::TABLE . "} ctx ON cl.id = ctx.contextlistid
1098                     WHERE rcl.requestid = ?";
1100         // Fetch records IDs to be updated and update by chunks, if applicable (limit of 1000 records per update).
1101         $limit = 1000;
1102         $idstoupdate = $DB->get_fieldset_sql($select, [$requestid]);
1103         $count = count($idstoupdate);
1104         $idchunks = $idstoupdate;
1105         if ($count > $limit) {
1106             $idchunks = array_chunk($idstoupdate, $limit);
1107         }
1108         $transaction = $DB->start_delegated_transaction();
1109         $initialparams = [$status];
1110         foreach ($idchunks as $chunk) {
1111             list($insql, $inparams) = $DB->get_in_or_equal($chunk);
1112             $update = "UPDATE {" . contextlist_context::TABLE . "}
1113                           SET status = ?
1114                         WHERE id $insql";
1115             $params = array_merge($initialparams, $inparams);
1116             $DB->execute($update, $params);
1117         }
1118         $transaction->allow_commit();
1119     }
1121     /**
1122      * Finds all request contextlists having at least on approved context, and returns them as in a contextlist_collection.
1123      *
1124      * @param data_request $request the data request with which the contextlists are associated.
1125      * @return contextlist_collection the collection of approved_contextlist objects.
1126      */
1127     public static function get_approved_contextlist_collection_for_request(data_request $request) : contextlist_collection {
1128         $foruser = core_user::get_user($request->get('userid'));
1130         // Fetch all approved contextlists and create the core_privacy\local\request\contextlist objects here.
1131         global $DB;
1132         $sql = "SELECT cl.component, ctx.contextid
1133                   FROM {" . request_contextlist::TABLE . "} rcl
1134                   JOIN {" . contextlist::TABLE . "} cl ON rcl.contextlistid = cl.id
1135                   JOIN {" . contextlist_context::TABLE . "} ctx ON cl.id = ctx.contextlistid
1136                  WHERE rcl.requestid = ?
1137                    AND ctx.status = ?
1138               ORDER BY cl.component, ctx.contextid";
1140         // Create the approved contextlist collection object.
1141         $lastcomponent = null;
1142         $approvedcollection = new contextlist_collection($foruser->id);
1144         $rs = $DB->get_recordset_sql($sql, [$request->get('id'), contextlist_context::STATUS_APPROVED]);
1145         foreach ($rs as $record) {
1146             // If we encounter a new component, and we've built up contexts for the last, then add the approved_contextlist for the
1147             // last (the one we've just finished with) and reset the context array for the next one.
1148             if ($lastcomponent != $record->component) {
1149                 if (!empty($contexts)) {
1150                     $approvedcollection->add_contextlist(new approved_contextlist($foruser, $lastcomponent, $contexts));
1151                 }
1152                 $contexts = [];
1153             }
1155             $contexts[] = $record->contextid;
1156             $lastcomponent = $record->component;
1157         }
1158         $rs->close();
1160         // The data for the last component contextlist won't have been written yet, so write it now.
1161         if (!empty($contexts)) {
1162             $approvedcollection->add_contextlist(new approved_contextlist($foruser, $lastcomponent, $contexts));
1163         }
1165         return $approvedcollection;
1166     }
1168     /**
1169      * Updates the default category and purpose for a given context level (and optionally, a plugin).
1170      *
1171      * @param int $contextlevel The context level.
1172      * @param int $categoryid The ID matching the category.
1173      * @param int $purposeid The ID matching the purpose record.
1174      * @param int $activity The name of the activity that we're making a defaults configuration for.
1175      * @param bool $override Whether to override the purpose/categories of existing instances to these defaults.
1176      * @return boolean True if set/unset config succeeds. Otherwise, it throws an exception.
1177      */
1178     public static function set_context_defaults($contextlevel, $categoryid, $purposeid, $activity = null, $override = false) {
1179         global $DB;
1181         self::check_can_manage_data_registry();
1183         // Get the class name associated with this context level.
1184         $classname = context_helper::get_class_for_level($contextlevel);
1185         list($purposevar, $categoryvar) = data_registry::var_names_from_context($classname, $activity);
1187         // Check the default category to be set.
1188         if ($categoryid == context_instance::INHERIT) {
1189             unset_config($categoryvar, 'tool_dataprivacy');
1191         } else {
1192             // Make sure the given category ID exists first.
1193             $categorypersistent = new category($categoryid);
1194             $categorypersistent->read();
1196             // Then set the new default value.
1197             set_config($categoryvar, $categoryid, 'tool_dataprivacy');
1198         }
1200         // Check the default purpose to be set.
1201         if ($purposeid == context_instance::INHERIT) {
1202             // If the defaults is set to inherit, just unset the config value.
1203             unset_config($purposevar, 'tool_dataprivacy');
1205         } else {
1206             // Make sure the given purpose ID exists first.
1207             $purposepersistent = new purpose($purposeid);
1208             $purposepersistent->read();
1210             // Then set the new default value.
1211             set_config($purposevar, $purposeid, 'tool_dataprivacy');
1212         }
1214         // Unset instances that have been assigned with custom purpose and category, if override was specified.
1215         if ($override) {
1216             // We'd like to find context IDs that we want to unset.
1217             $statements = ["SELECT c.id as contextid FROM {context} c"];
1218             // Based on this context level.
1219             $params = ['contextlevel' => $contextlevel];
1221             if ($contextlevel == CONTEXT_MODULE) {
1222                 // If we're deleting module context instances, we need to make sure the instance ID is in the course modules table.
1223                 $statements[] = "JOIN {course_modules} cm ON cm.id = c.instanceid";
1224                 // And that the module is listed on the modules table.
1225                 $statements[] = "JOIN {modules} m ON m.id = cm.module";
1227                 if ($activity) {
1228                     // If we're overriding for an activity module, make sure that the context instance matches that activity.
1229                     $statements[] = "AND m.name = :modname";
1230                     $params['modname'] = $activity;
1231                 }
1232             }
1233             // Make sure this context instance exists in the tool_dataprivacy_ctxinstance table.
1234             $statements[] = "JOIN {tool_dataprivacy_ctxinstance} tdc ON tdc.contextid = c.id";
1235             // And that the context level of this instance matches the given context level.
1236             $statements[] = "WHERE c.contextlevel = :contextlevel";
1238             // Build our SQL query by gluing the statements.
1239             $sql = implode("\n", $statements);
1241             // Get the context records matching our query.
1242             $contextids = $DB->get_fieldset_sql($sql, $params);
1244             // Delete the matching context instances.
1245             foreach ($contextids as $contextid) {
1246                 if ($instance = context_instance::get_record_by_contextid($contextid, false)) {
1247                     self::unset_context_instance($instance);
1248                 }
1249             }
1250         }
1252         return true;
1253     }