MDL-50851 core_tag: introduce tag collections
[moodle.git] / tag / classes / external.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 class core_tag_external
19  *
20  * @package    core_tag
21  * @copyright  2015 Marina Glancy
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 require_once("$CFG->libdir/externallib.php");
26 require_once("$CFG->dirroot/webservice/externallib.php");
28 /**
29  * Tags-related web services
30  *
31  * @package    core_tag
32  * @copyright  2015 Marina Glancy
33  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
34  */
35 class core_tag_external extends external_api {
37     /**
38      * Parameters for function update_tags()
39      *
40      * @return external_function_parameters
41      */
42     public static function update_tags_parameters() {
43         return new external_function_parameters(
44             array(
45                 'tags' => new external_multiple_structure(
46                     new external_single_structure(
47                         array(
48                             'id' => new external_value(PARAM_INT, 'tag id'),
49                             'rawname' => new external_value(PARAM_RAW, 'tag raw name (may contain capital letters)',
50                                     VALUE_OPTIONAL),
51                             'description' => new external_value(PARAM_RAW, 'tag description', VALUE_OPTIONAL),
52                             'descriptionformat' => new external_value(PARAM_INT, 'tag description format', VALUE_OPTIONAL),
53                             'flag' => new external_value(PARAM_INT, 'flag', VALUE_OPTIONAL),
54                             'official' => new external_value(PARAM_INT, 'whether this flag is official', VALUE_OPTIONAL),
55                         )
56                     )
57                 )
58             )
59         );
60     }
62     /**
63      * Update tags
64      *
65      * @param array $tags
66      */
67     public static function update_tags($tags) {
68         global $CFG, $PAGE, $DB;
70         // Validate and normalize parameters.
71         $tags = self::validate_parameters(self::update_tags_parameters(), array('tags' => $tags));
73         $systemcontext = context_system::instance();
74         $canmanage = has_capability('moodle/tag:manage', $systemcontext);
75         $canedit = has_capability('moodle/tag:edit', $systemcontext);
76         $warnings = array();
78         if (empty($CFG->usetags)) {
79             throw new moodle_exception('tagsaredisabled', 'tag');
80         }
82         $renderer = $PAGE->get_renderer('core');
83         foreach ($tags['tags'] as $tag) {
84             $tag = (array)$tag;
85             if (array_key_exists('rawname', $tag)) {
86                 $tag['rawname'] = clean_param($tag['rawname'], PARAM_TAG);
87                 if (empty($tag['rawname'])) {
88                     unset($tag['rawname']);
89                 }
90             }
91             if (!$canmanage) {
92                 // User without manage capability can not change any fields except for descriptions.
93                 $tag = array_intersect_key($tag, array('id' => 1,
94                     'description' => 1, 'descriptionformat' => 1));
95             }
96             if (!$canedit) {
97                 // User without edit capability can not change description.
98                 $tag = array_diff_key($tag,
99                         array('description' => 1, 'descriptionformat' => 1));
100             }
101             if (count($tag) <= 1) {
102                 $warnings[] = array(
103                     'item' => $tag['id'],
104                     'warningcode' => 'nothingtoupdate',
105                     'message' => get_string('nothingtoupdate', 'core_tag')
106                 );
107                 continue;
108             }
109             if (!$tagobject = core_tag_tag::get($tag['id'], '*')) {
110                 $warnings[] = array(
111                     'item' => $tag['id'],
112                     'warningcode' => 'tagnotfound',
113                     'message' => get_string('tagnotfound', 'error')
114                 );
115                 continue;
116             }
117             // First check if new tag name is allowed.
118             if (!empty($tag['rawname']) && ($existing = core_tag_tag::get_by_name($tagobject->tagcollid, $tag['rawname']))) {
119                 if ($existing->id != $tag['id']) {
120                     $warnings[] = array(
121                         'item' => $tag['id'],
122                         'warningcode' => 'namesalreadybeeingused',
123                         'message' => get_string('namesalreadybeeingused', 'core_tag')
124                     );
125                     continue;
126                 }
127             }
128             if (array_key_exists('official', $tag)) {
129                 $tag['tagtype'] = $tag['official'] ? 'official' : 'default';
130                 unset($tag['official']);
131             }
132             if (isset($tag['flag'])) {
133                 if ($tag['flag']) {
134                     $tagobject->flag();
135                 } else {
136                     $tagobject->reset_flag();
137                 }
138                 unset($tag['flag']);
139             }
140             unset($tag['id']);
141             if (count($tag)) {
142                 $tagobject->update($tag);
143             }
144         }
145         return array('warnings' => $warnings);
146     }
148     /**
149      * Return structure for update_tag()
150      *
151      * @return external_description
152      */
153     public static function update_tags_returns() {
154         return new external_single_structure(
155             array(
156                 'warnings' => new external_warnings()
157             )
158         );
159     }
161     /**
162      * Parameters for function get_tags()
163      *
164      * @return external_function_parameters
165      */
166     public static function get_tags_parameters() {
167         return new external_function_parameters(
168             array(
169                 'tags' => new external_multiple_structure(
170                     new external_single_structure(
171                         array(
172                             'id' => new external_value(PARAM_INT, 'tag id'),
173                         )
174                     )
175                 )
176             )
177         );
178     }
180     /**
181      * Get tags by their ids
182      *
183      * @param array $tags
184      */
185     public static function get_tags($tags) {
186         global $CFG, $PAGE, $DB;
188         // Validate and normalize parameters.
189         $tags = self::validate_parameters(self::get_tags_parameters(), array('tags' => $tags));
191         require_login(null, false, null, false, true);
193         $systemcontext = context_system::instance();
194         $canmanage = has_capability('moodle/tag:manage', $systemcontext);
195         $canedit = has_capability('moodle/tag:edit', $systemcontext);
197         $return = array();
198         $warnings = array();
200         if (empty($CFG->usetags)) {
201             throw new moodle_exception('tagsaredisabled', 'tag');
202         }
204         $renderer = $PAGE->get_renderer('core');
205         foreach ($tags['tags'] as $tag) {
206             $tag = (array)$tag;
207             if (!$tagobject = $DB->get_record('tag', array('id' => $tag['id']))) {
208                 $warnings[] = array(
209                     'item' => $tag['id'],
210                     'warningcode' => 'tagnotfound',
211                     'message' => get_string('tagnotfound', 'error')
212                 );
213                 continue;
214             }
215             $tagoutput = new \core_tag\output\tag($tagobject);
216             // Do not return some information to users without permissions.
217             $rv = $tagoutput->export_for_template($renderer);
218             if (!$canmanage) {
219                 if (!$canedit) {
220                     unset($rv->official);
221                 }
222                 unset($rv->flag);
223                 unset($rv->changetypeurl);
224                 unset($rv->changeflagurl);
225             }
226             $return[] = $rv;
227         }
228         return array('tags' => $return, 'warnings' => $warnings);
229     }
231     /**
232      * Return structure for get_tag()
233      *
234      * @return external_description
235      */
236     public static function get_tags_returns() {
237         return new external_single_structure(
238             array(
239                 'tags' => new external_multiple_structure( new external_single_structure(
240                     array(
241                         'id' => new external_value(PARAM_INT, 'tag id'),
242                         'tagcollid' => new external_value(PARAM_INT, 'tag collection id'),
243                         'name' => new external_value(PARAM_TAG, 'name'),
244                         'rawname' => new external_value(PARAM_RAW, 'tag raw name (may contain capital letters)'),
245                         'description' => new external_value(PARAM_RAW, 'tag description'),
246                         'descriptionformat' => new external_format_value(PARAM_INT, 'tag description format'),
247                         'flag' => new external_value(PARAM_INT, 'flag', VALUE_OPTIONAL),
248                         'official' => new external_value(PARAM_INT, 'whether this flag is official', VALUE_OPTIONAL),
249                         'viewurl' => new external_value(PARAM_URL, 'URL to view'),
250                         'changetypeurl' => new external_value(PARAM_URL, 'URL to change type (official or not)', VALUE_OPTIONAL),
251                         'changeflagurl' => new external_value(PARAM_URL, 'URL to set or reset flag', VALUE_OPTIONAL),
252                     ), 'information about one tag')
253                 ),
254                 'warnings' => new external_warnings()
255             )
256         );
257     }
259     /**
260      * Parameters for function get_tagindex()
261      *
262      * @return external_function_parameters
263      */
264     public static function get_tagindex_parameters() {
265         return new external_function_parameters(
266             array(
267                 'tagindex' => new external_single_structure(array(
268                     'tag' => new external_value(PARAM_TAG, 'tag name'),
269                     'tc' => new external_value(PARAM_INT, 'tag collection id'),
270                     'ta' => new external_value(PARAM_INT, 'tag area id'),
271                     'excl' => new external_value(PARAM_BOOL, 'exlusive mode for this tag area', VALUE_OPTIONAL, 0),
272                     'from' => new external_value(PARAM_INT, 'context id where the link was displayed', VALUE_OPTIONAL, 0),
273                     'ctx' => new external_value(PARAM_INT, 'context id where to search for items', VALUE_OPTIONAL, 0),
274                     'rec' => new external_value(PARAM_INT, 'search in the context recursive', VALUE_OPTIONAL, 1),
275                     'page' => new external_value(PARAM_INT, 'page number (0-based)', VALUE_OPTIONAL, 0),
276                 ), 'parameters')
277             )
278         );
279     }
281     /**
282      * Get tags by their ids
283      *
284      * @param array $params
285      */
286     public static function get_tagindex($params) {
287         global $PAGE;
288         // Validate and normalize parameters.
289         $tagindex = self::validate_parameters(
290                 self::get_tagindex_parameters(), array('tagindex' => $params));
291         $params = $tagindex['tagindex'] + array(
292             'excl' => 0,
293             'from' => 0,
294             'ctx' => 0,
295             'rec' => 1,
296             'page' => 0
297         );
299         // Login to the course / module if applicable.
300         $context = $params['ctx'] ? context::instance_by_id($params['ctx']) : context_system::instance();
301         require_login(null, false, null, false, true);
302         self::validate_context($context);
304         $tag = core_tag_tag::get_by_name($params['tc'], $params['tag'], '*', MUST_EXIST);
305         $tagareas = core_tag_collection::get_areas($params['tc']);
306         $tagindex = $tag->get_tag_index($tagareas[$params['ta']], $params['excl'], $params['from'],
307                 $params['ctx'], $params['rec'], $params['page']);
308         $renderer = $PAGE->get_renderer('core');
309         return $tagindex->export_for_template($renderer);
310     }
312     /**
313      * Return structure for get_tag()
314      *
315      * @return external_description
316      */
317     public static function get_tagindex_returns() {
318         return new external_single_structure(
319             array(
320                 'tagid' => new external_value(PARAM_INT, 'tag id'),
321                 'ta' => new external_value(PARAM_INT, 'tag area id'),
322                 'component' => new external_value(PARAM_COMPONENT, 'component'),
323                 'itemtype' => new external_value(PARAM_NOTAGS, 'itemtype'),
324                 'nextpageurl' => new external_value(PARAM_URL, 'URL for the next page', VALUE_OPTIONAL),
325                 'prevpageurl' => new external_value(PARAM_URL, 'URL for the next page', VALUE_OPTIONAL),
326                 'exclusiveurl' => new external_value(PARAM_URL, 'URL for exclusive link', VALUE_OPTIONAL),
327                 'exclusivetext' => new external_value(PARAM_TEXT, 'text for exclusive link', VALUE_OPTIONAL),
328                 'title' => new external_value(PARAM_RAW, 'title'),
329                 'content' => new external_value(PARAM_RAW, 'title'),
330                 'hascontent' => new external_value(PARAM_INT, 'whether the content is present'),
331                 'anchor' => new external_value(PARAM_TEXT, 'name of anchor', VALUE_OPTIONAL),
332             ), 'tag index'
333         );
334     }