Proyectos de Subversion Moodle

Rev

| Ultima modificación | Ver Log |

Rev Autor Línea Nro. Línea
1 efrain 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/>.
16
 
17
/**
18
 * Collection of helper functions for the data privacy tool.
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\local;
25
defined('MOODLE_INTERNAL') || die();
26
 
27
use coding_exception;
28
use moodle_exception;
29
use tool_dataprivacy\api;
30
use tool_dataprivacy\data_request;
31
 
32
/**
33
 * Class containing helper functions for the data privacy tool.
34
 *
35
 * @copyright  2018 Jun Pataleta
36
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
37
 */
38
class helper {
39
    /** The default number of results to be shown per page. */
40
    const DEFAULT_PAGE_SIZE = 20;
41
 
42
    /** Filter constant associated with the request type filter. */
43
    const FILTER_TYPE = 1;
44
 
45
    /** Filter constant associated with the request status filter. */
46
    const FILTER_STATUS = 2;
47
 
48
    /** Filter constant associated with the request creation filter. */
49
    const FILTER_CREATION = 3;
50
 
51
    /** The request filters preference key. */
52
    const PREF_REQUEST_FILTERS = 'tool_dataprivacy_request-filters';
53
 
54
    /** The number of data request records per page preference key. */
55
    const PREF_REQUEST_PERPAGE = 'tool_dataprivacy_request-perpage';
56
 
57
    /**
58
     * Retrieves the human-readable text value of a data request type.
59
     *
60
     * @param int $requesttype The request type.
61
     * @return string
62
     * @throws coding_exception
63
     * @throws moodle_exception
64
     */
65
    public static function get_request_type_string($requesttype) {
66
        $types = self::get_request_types();
67
        if (!isset($types[$requesttype])) {
68
            throw new moodle_exception('errorinvalidrequesttype', 'tool_dataprivacy');
69
        }
70
        return $types[$requesttype];
71
    }
72
 
73
    /**
74
     * Retrieves the human-readable shortened text value of a data request type.
75
     *
76
     * @param int $requesttype The request type.
77
     * @return string
78
     * @throws coding_exception
79
     * @throws moodle_exception
80
     */
81
    public static function get_shortened_request_type_string($requesttype) {
82
        $types = self::get_request_types_short();
83
        if (!isset($types[$requesttype])) {
84
            throw new moodle_exception('errorinvalidrequesttype', 'tool_dataprivacy');
85
        }
86
        return $types[$requesttype];
87
    }
88
 
89
    /**
90
     * Returns the key value-pairs of request type code and their string value.
91
     *
92
     * @return array
93
     */
94
    public static function get_request_types() {
95
        return [
96
            api::DATAREQUEST_TYPE_EXPORT => get_string('requesttypeexport', 'tool_dataprivacy'),
97
            api::DATAREQUEST_TYPE_DELETE => get_string('requesttypedelete', 'tool_dataprivacy'),
98
            api::DATAREQUEST_TYPE_OTHERS => get_string('requesttypeothers', 'tool_dataprivacy'),
99
        ];
100
    }
101
 
102
    /**
103
     * Returns the key value-pairs of request type code and their shortened string value.
104
     *
105
     * @return array
106
     */
107
    public static function get_request_types_short() {
108
        return [
109
            api::DATAREQUEST_TYPE_EXPORT => get_string('requesttypeexportshort', 'tool_dataprivacy'),
110
            api::DATAREQUEST_TYPE_DELETE => get_string('requesttypedeleteshort', 'tool_dataprivacy'),
111
            api::DATAREQUEST_TYPE_OTHERS => get_string('requesttypeothersshort', 'tool_dataprivacy'),
112
        ];
113
    }
114
 
115
    /**
116
     * Retrieves the human-readable value of a data request status.
117
     *
118
     * @param int $status The request status.
119
     * @return string
120
     * @throws moodle_exception
121
     */
122
    public static function get_request_status_string($status) {
123
        $statuses = self::get_request_statuses();
124
        if (!isset($statuses[$status])) {
125
            throw new moodle_exception('errorinvalidrequeststatus', 'tool_dataprivacy');
126
        }
127
 
128
        return $statuses[$status];
129
    }
130
 
131
    /**
132
     * Returns the key value-pairs of request status code and string value.
133
     *
134
     * @return array
135
     */
136
    public static function get_request_statuses() {
137
        return [
138
            api::DATAREQUEST_STATUS_PENDING => get_string('statuspending', 'tool_dataprivacy'),
139
            api::DATAREQUEST_STATUS_PREPROCESSING => get_string('statuspreprocessing', 'tool_dataprivacy'),
140
            api::DATAREQUEST_STATUS_AWAITING_APPROVAL => get_string('statusawaitingapproval', 'tool_dataprivacy'),
141
            api::DATAREQUEST_STATUS_APPROVED => get_string('statusapproved', 'tool_dataprivacy'),
142
            api::DATAREQUEST_STATUS_PROCESSING => get_string('statusprocessing', 'tool_dataprivacy'),
143
            api::DATAREQUEST_STATUS_COMPLETE => get_string('statuscomplete', 'tool_dataprivacy'),
144
            api::DATAREQUEST_STATUS_DOWNLOAD_READY => get_string('statusready', 'tool_dataprivacy'),
145
            api::DATAREQUEST_STATUS_EXPIRED => get_string('statusexpired', 'tool_dataprivacy'),
146
            api::DATAREQUEST_STATUS_CANCELLED => get_string('statuscancelled', 'tool_dataprivacy'),
147
            api::DATAREQUEST_STATUS_REJECTED => get_string('statusrejected', 'tool_dataprivacy'),
148
            api::DATAREQUEST_STATUS_DELETED => get_string('statusdeleted', 'tool_dataprivacy'),
149
        ];
150
    }
151
 
152
    /**
153
     * Retrieves the human-readable value of a data request creation method.
154
     *
155
     * @param int $creation The request creation method.
156
     * @return string
157
     * @throws moodle_exception
158
     */
159
    public static function get_request_creation_method_string($creation) {
160
        $creationmethods = self::get_request_creation_methods();
161
        if (!isset($creationmethods[$creation])) {
162
            throw new moodle_exception('errorinvalidrequestcreationmethod', 'tool_dataprivacy');
163
        }
164
 
165
        return $creationmethods[$creation];
166
    }
167
 
168
    /**
169
     * Returns the key value-pairs of request creation method code and string value.
170
     *
171
     * @return array
172
     */
173
    public static function get_request_creation_methods() {
174
        return [
175
            data_request::DATAREQUEST_CREATION_MANUAL => get_string('creationmanual', 'tool_dataprivacy'),
176
            data_request::DATAREQUEST_CREATION_AUTO => get_string('creationauto', 'tool_dataprivacy'),
177
        ];
178
    }
179
 
180
    /**
181
     * Get the users that a user can make data request for.
182
     *
183
     * E.g. User having a parent role and has the 'tool/dataprivacy:makedatarequestsforchildren' capability.
184
     * @param int $userid The user's ID.
185
     * @return array
186
     */
187
    public static function get_children_of_user($userid) {
188
        global $DB;
189
 
190
        // Get users that the user has role assignments to.
191
        $userfieldsapi = \core_user\fields::for_name();
192
        $allusernames = $userfieldsapi->get_sql('u', false, '', '', false)->selects;
193
        $sql = "SELECT u.id, $allusernames
194
                  FROM {role_assignments} ra, {context} c, {user} u
195
                 WHERE ra.userid = :userid
196
                       AND ra.contextid = c.id
197
                       AND c.instanceid = u.id
198
                       AND c.contextlevel = :contextlevel";
199
        $params = [
200
            'userid' => $userid,
201
            'contextlevel' => CONTEXT_USER
202
        ];
203
 
204
        // The final list of users that we will return.
205
        $finalresults = [];
206
 
207
        // Our prospective list of users.
208
        if ($candidates = $DB->get_records_sql($sql, $params)) {
209
            foreach ($candidates as $key => $child) {
210
                $childcontext = \context_user::instance($child->id);
211
                if (has_capability('tool/dataprivacy:makedatarequestsforchildren', $childcontext, $userid)) {
212
                    $finalresults[$key] = $child;
213
                }
214
            }
215
        }
216
        return $finalresults;
217
    }
218
 
219
    /**
220
     * Get options for the data requests filter.
221
     *
222
     * @return array
223
     * @throws coding_exception
224
     */
225
    public static function get_request_filter_options() {
226
        $filters = [
227
            self::FILTER_TYPE => (object)[
228
                'name' => get_string('requesttype', 'tool_dataprivacy'),
229
                'options' => self::get_request_types_short()
230
            ],
231
            self::FILTER_STATUS => (object)[
232
                'name' => get_string('requeststatus', 'tool_dataprivacy'),
233
                'options' => self::get_request_statuses()
234
            ],
235
            self::FILTER_CREATION => (object)[
236
                'name' => get_string('requestcreation', 'tool_dataprivacy'),
237
                'options' => self::get_request_creation_methods()
238
            ],
239
        ];
240
        $options = [];
241
        foreach ($filters as $category => $filtercategory) {
242
            foreach ($filtercategory->options as $key => $name) {
243
                $option = (object)[
244
                    'category' => $filtercategory->name,
245
                    'name' => $name
246
                ];
247
                $options["{$category}:{$key}"] = get_string('filteroption', 'tool_dataprivacy', $option);
248
            }
249
        }
250
        return $options;
251
    }
252
}