Merge branch 'MDL-62589-master' of git://github.com/andrewnicols/moodle
[moodle.git] / admin / tool / dataprivacy / classes / output / data_requests_table.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  * Contains the class used for the displaying the data requests table.
19  *
20  * @package    tool_dataprivacy
21  * @copyright  2018 Jun Pataleta <jun@moodle.com>
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 require_once($CFG->libdir . '/tablelib.php');
29 use action_menu;
30 use action_menu_link_secondary;
31 use coding_exception;
32 use dml_exception;
33 use html_writer;
34 use moodle_url;
35 use stdClass;
36 use table_sql;
37 use tool_dataprivacy\api;
38 use tool_dataprivacy\external\data_request_exporter;
40 defined('MOODLE_INTERNAL') || die;
42 /**
43  * The class for displaying the data requests table.
44  *
45  * @copyright  2018 Jun Pataleta <jun@moodle.com>
46  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
47  */
48 class data_requests_table extends table_sql {
50     /** @var int The user ID. */
51     protected $userid = 0;
53     /** @var int[] The status filters. */
54     protected $statuses = [];
56     /** @var int[] The request type filters.  */
57     protected $types = [];
59     /** @var bool Whether this table is being rendered for managing data requests. */
60     protected $manage = false;
62     /** @var \tool_dataprivacy\data_request[] Array of data request persistents. */
63     protected $datarequests = [];
65     /** @var \stdClass[] List of userids and whether they have any ongoing active requests. */
66     protected $ongoingrequests = [];
68     /** @var int The number of data request to be displayed per page. */
69     protected $perpage;
71     /** @var int[] The available options for the number of data request to be displayed per page. */
72     protected $perpageoptions = [25, 50, 100, 250];
74     /**
75      * data_requests_table constructor.
76      *
77      * @param int $userid The user ID
78      * @param int[] $statuses
79      * @param int[] $types
80      * @param int[] $creationmethods
81      * @param bool $manage
82      * @throws coding_exception
83      */
84     public function __construct($userid = 0, $statuses = [], $types = [], $creationmethods = [], $manage = false) {
85         parent::__construct('data-requests-table');
87         $this->userid = $userid;
88         $this->statuses = $statuses;
89         $this->types = $types;
90         $this->creationmethods = $creationmethods;
91         $this->manage = $manage;
93         $checkboxattrs = [
94             'title' => get_string('selectall'),
95             'data-action' => 'selectall'
96         ];
98         $columnheaders = [
99             'select' => html_writer::checkbox('selectall', 1, false, null, $checkboxattrs),
100             'type' => get_string('requesttype', 'tool_dataprivacy'),
101             'userid' => get_string('user', 'tool_dataprivacy'),
102             'timecreated' => get_string('daterequested', 'tool_dataprivacy'),
103             'requestedby' => get_string('requestby', 'tool_dataprivacy'),
104             'status' => get_string('requeststatus', 'tool_dataprivacy'),
105             'comments' => get_string('message', 'tool_dataprivacy'),
106             'actions' => '',
107         ];
109         $this->define_columns(array_keys($columnheaders));
110         $this->define_headers(array_values($columnheaders));
111         $this->no_sorting('select', 'actions');
112     }
114     /**
115      * The select column.
116      *
117      * @param stdClass $data The row data.
118      * @return string
119      */
120     public function col_select($data) {
121         if ($data->status == \tool_dataprivacy\api::DATAREQUEST_STATUS_AWAITING_APPROVAL) {
122             $stringdata = [
123                 'username' => $data->foruser->fullname,
124                 'requesttype' => \core_text::strtolower($data->typenameshort)
125             ];
127             return \html_writer::checkbox('requestids[]', $data->id, false, '',
128                     ['class' => 'selectrequests', 'title' => get_string('selectuserdatarequest',
129                     'tool_dataprivacy', $stringdata)]);
130         }
131     }
133     /**
134      * The type column.
135      *
136      * @param stdClass $data The row data.
137      * @return string
138      */
139     public function col_type($data) {
140         if ($this->manage) {
141             return $data->typenameshort;
142         }
143         return $data->typename;
144     }
146     /**
147      * The user column.
148      *
149      * @param stdClass $data The row data.
150      * @return mixed
151      */
152     public function col_userid($data) {
153         $user = $data->foruser;
154         return html_writer::link($user->profileurl, $user->fullname, ['title' => get_string('viewprofile')]);
155     }
157     /**
158      * The context information column.
159      *
160      * @param stdClass $data The row data.
161      * @return string
162      */
163     public function col_timecreated($data) {
164         return userdate($data->timecreated);
165     }
167     /**
168      * The requesting user's column.
169      *
170      * @param stdClass $data The row data.
171      * @return mixed
172      */
173     public function col_requestedby($data) {
174         $user = $data->requestedbyuser;
175         return html_writer::link($user->profileurl, $user->fullname, ['title' => get_string('viewprofile')]);
176     }
178     /**
179      * The status column.
180      *
181      * @param stdClass $data The row data.
182      * @return mixed
183      */
184     public function col_status($data) {
185         return html_writer::span($data->statuslabel, 'label ' . $data->statuslabelclass);
186     }
188     /**
189      * The comments column.
190      *
191      * @param stdClass $data The row data.
192      * @return string
193      */
194     public function col_comments($data) {
195         return shorten_text($data->comments, 60);
196     }
198     /**
199      * The actions column.
200      *
201      * @param stdClass $data The row data.
202      * @return string
203      */
204     public function col_actions($data) {
205         global $OUTPUT;
207         $requestid = $data->id;
208         $status = $data->status;
210         // Prepare actions.
211         $actions = [];
213         // View action.
214         $actionurl = new moodle_url('#');
215         $actiondata = ['data-action' => 'view', 'data-requestid' => $requestid];
216         $actiontext = get_string('viewrequest', 'tool_dataprivacy');
217         $actions[] = new action_menu_link_secondary($actionurl, null, $actiontext, $actiondata);
219         switch ($status) {
220             case api::DATAREQUEST_STATUS_PENDING:
221                 // Add action to mark a general enquiry request as complete.
222                 if ($data->type == api::DATAREQUEST_TYPE_OTHERS) {
223                     $actiondata['data-action'] = 'complete';
224                     $nameemail = (object)[
225                         'name' => $data->foruser->fullname,
226                         'email' => $data->foruser->email
227                     ];
228                     $actiondata['data-requestid'] = $data->id;
229                     $actiondata['data-replytoemail'] = get_string('nameemail', 'tool_dataprivacy', $nameemail);
230                     $actiontext = get_string('markcomplete', 'tool_dataprivacy');
231                     $actions[] = new action_menu_link_secondary($actionurl, null, $actiontext, $actiondata);
232                 }
233                 break;
234             case api::DATAREQUEST_STATUS_AWAITING_APPROVAL:
235                 // Approve.
236                 $actiondata['data-action'] = 'approve';
237                 $actiontext = get_string('approverequest', 'tool_dataprivacy');
238                 $actions[] = new action_menu_link_secondary($actionurl, null, $actiontext, $actiondata);
240                 // Deny.
241                 $actiondata['data-action'] = 'deny';
242                 $actiontext = get_string('denyrequest', 'tool_dataprivacy');
243                 $actions[] = new action_menu_link_secondary($actionurl, null, $actiontext, $actiondata);
244                 break;
245             case api::DATAREQUEST_STATUS_DOWNLOAD_READY:
246                 $userid = $data->foruser->id;
247                 $usercontext = \context_user::instance($userid, IGNORE_MISSING);
248                 // If user has permission to view download link, show relevant action item.
249                 if ($usercontext && api::can_download_data_request_for_user($userid, $data->requestedbyuser->id)) {
250                     $actions[] = api::get_download_link($usercontext, $requestid);
251                 }
252                 break;
253         }
255         if ($this->manage) {
256             $persistent = $this->datarequests[$requestid];
257             $canreset = $persistent->is_active() || empty($this->ongoingrequests[$data->foruser->id]->{$data->type});
258             $canreset = $canreset && $persistent->is_resettable();
259             if ($canreset) {
260                 $reseturl = new moodle_url('/admin/tool/dataprivacy/resubmitrequest.php', [
261                         'requestid' => $requestid,
262                     ]);
263                 $actiondata = ['data-action' => 'reset', 'data-requestid' => $requestid];
264                 $actiontext = get_string('resubmitrequestasnew', 'tool_dataprivacy');
265                 $actions[] = new action_menu_link_secondary($reseturl, null, $actiontext, $actiondata);
266             }
267         }
269         $actionsmenu = new action_menu($actions);
270         $actionsmenu->set_menu_trigger(get_string('actions'));
271         $actionsmenu->set_owner_selector('request-actions-' . $requestid);
272         $actionsmenu->set_alignment(\action_menu::TL, \action_menu::BL);
273         $actionsmenu->set_constraint('[data-region=data-requests-table] > .no-overflow');
275         return $OUTPUT->render($actionsmenu);
276     }
278     /**
279      * Query the database for results to display in the table.
280      *
281      * @param int $pagesize size of page for paginated displayed table.
282      * @param bool $useinitialsbar do you want to use the initials bar.
283      * @throws dml_exception
284      * @throws coding_exception
285      */
286     public function query_db($pagesize, $useinitialsbar = true) {
287         global $PAGE;
289         // Set dummy page total until we fetch full result set.
290         $this->pagesize($pagesize, $pagesize + 1);
292         $sort = $this->get_sql_sort();
294         // Get data requests from the given conditions.
295         $datarequests = api::get_data_requests($this->userid, $this->statuses, $this->types,
296                 $this->creationmethods, $sort, $this->get_page_start(), $this->get_page_size());
298         // Count data requests from the given conditions.
299         $total = api::get_data_requests_count($this->userid, $this->statuses, $this->types,
300                 $this->creationmethods);
301         $this->pagesize($pagesize, $total);
303         $this->rawdata = [];
304         $context = \context_system::instance();
305         $renderer = $PAGE->get_renderer('tool_dataprivacy');
307         $forusers = [];
308         foreach ($datarequests as $persistent) {
309             $this->datarequests[$persistent->get('id')] = $persistent;
310             $exporter = new data_request_exporter($persistent, ['context' => $context]);
311             $this->rawdata[] = $exporter->export($renderer);
312             $forusers[] = $persistent->get('userid');
313         }
315         // Fetch the list of all ongoing requests for the users currently shown.
316         // This is used to determine whether any non-active request can be resubmitted.
317         // There can only be one ongoing request of a type for each user.
318         $this->ongoingrequests = api::find_ongoing_request_types_for_users($forusers);
320         // Set initial bars.
321         if ($useinitialsbar) {
322             $this->initialbars($total > $pagesize);
323         }
324     }
326     /**
327      * Override default implementation to display a more meaningful information to the user.
328      */
329     public function print_nothing_to_display() {
330         global $OUTPUT;
331         echo $this->render_reset_button();
332         $this->print_initials_bar();
333         if (!empty($this->statuses) || !empty($this->types)) {
334             $message = get_string('nodatarequestsmatchingfilter', 'tool_dataprivacy');
335         } else {
336             $message = get_string('nodatarequests', 'tool_dataprivacy');
337         }
338         echo $OUTPUT->notification($message, 'warning');
339     }
341     /**
342      * Override the table's show_hide_link method to prevent the show/hide links from rendering.
343      *
344      * @param string $column the column name, index into various names.
345      * @param int $index numerical index of the column.
346      * @return string HTML fragment.
347      */
348     protected function show_hide_link($column, $index) {
349         return '';
350     }
352     /**
353      * Override the table's wrap_html_finish method in order to render the bulk actions and
354      * records per page options.
355      */
356     public function wrap_html_finish() {
357         global $OUTPUT;
359         $data = new stdClass();
360         $data->options = [
361             [
362                 'value' => 0,
363                 'name' => ''
364             ],
365             [
366                 'value' => \tool_dataprivacy\api::DATAREQUEST_ACTION_APPROVE,
367                 'name' => get_string('approve', 'tool_dataprivacy')
368             ],
369             [
370                 'value' => \tool_dataprivacy\api::DATAREQUEST_ACTION_REJECT,
371                 'name' => get_string('deny', 'tool_dataprivacy')
372             ]
373         ];
375         $perpageoptions = array_combine($this->perpageoptions, $this->perpageoptions);
376         $perpageselect = new \single_select(new moodle_url(''), 'perpage',
377                 $perpageoptions, get_user_preferences('tool_dataprivacy_request-perpage'), null, 'selectgroup');
378         $perpageselect->label = get_string('perpage', 'moodle');
379         $data->perpage = $OUTPUT->render($perpageselect);
381         echo $OUTPUT->render_from_template('tool_dataprivacy/data_requests_bulk_actions', $data);
382     }
384     /**
385      * Set the number of data request records to be displayed per page.
386      *
387      * @param int $perpage The number of data request records.
388      */
389     public function set_requests_per_page(int $perpage) {
390         $this->perpage = $perpage;
391     }
393     /**
394      * Get the number of data request records to be displayed per page.
395      *
396      * @return int The number of data request records.
397      */
398     public function get_requests_per_page() : int {
399         return $this->perpage;
400     }
402     /**
403      * Set the available options for the number of data request to be displayed per page.
404      *
405      * @param array $perpageoptions The available options for the number of data request to be displayed per page.
406      */
407     public function set_requests_per_page_options(array $perpageoptions) {
408         $this->$perpageoptions = $perpageoptions;
409     }
411     /**
412      * Get the available options for the number of data request to be displayed per page.
413      *
414      * @return array The available options for the number of data request to be displayed per page.
415      */
416     public function get_requests_per_page_options() : array {
417         return $this->perpageoptions;
418     }