MDL-64656 core_tag: New WebService core_tag_get_tag_cloud
[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 defined('MOODLE_INTERNAL') || die();
27 require_once("$CFG->libdir/externallib.php");
28 require_once("$CFG->dirroot/webservice/externallib.php");
30 /**
31  * Tags-related web services
32  *
33  * @package    core_tag
34  * @copyright  2015 Marina Glancy
35  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
36  */
37 class core_tag_external extends external_api {
39     /**
40      * Parameters for function update_tags()
41      *
42      * @return external_function_parameters
43      */
44     public static function update_tags_parameters() {
45         return new external_function_parameters(
46             array(
47                 'tags' => new external_multiple_structure(
48                     new external_single_structure(
49                         array(
50                             'id' => new external_value(PARAM_INT, 'tag id'),
51                             'rawname' => new external_value(PARAM_RAW, 'tag raw name (may contain capital letters)',
52                                     VALUE_OPTIONAL),
53                             'description' => new external_value(PARAM_RAW, 'tag description', VALUE_OPTIONAL),
54                             'descriptionformat' => new external_value(PARAM_INT, 'tag description format', VALUE_OPTIONAL),
55                             'flag' => new external_value(PARAM_INT, 'flag', VALUE_OPTIONAL),
56                             'official' => new external_value(PARAM_INT,
57                                 '(deprecated, use isstandard) whether this flag is standard', VALUE_OPTIONAL),
58                             'isstandard' => new external_value(PARAM_INT, 'whether this flag is standard', VALUE_OPTIONAL),
59                         )
60                     )
61                 )
62             )
63         );
64     }
66     /**
67      * Update tags
68      *
69      * @param array $tags
70      */
71     public static function update_tags($tags) {
72         global $CFG, $PAGE, $DB;
74         // Validate and normalize parameters.
75         $tags = self::validate_parameters(self::update_tags_parameters(), array('tags' => $tags));
77         $systemcontext = context_system::instance();
78         $canmanage = has_capability('moodle/tag:manage', $systemcontext);
79         $canedit = has_capability('moodle/tag:edit', $systemcontext);
80         $warnings = array();
82         if (empty($CFG->usetags)) {
83             throw new moodle_exception('tagsaredisabled', 'tag');
84         }
86         $renderer = $PAGE->get_renderer('core');
87         foreach ($tags['tags'] as $tag) {
88             $tag = (array)$tag;
89             if (array_key_exists('rawname', $tag)) {
90                 $tag['rawname'] = clean_param($tag['rawname'], PARAM_TAG);
91                 if (empty($tag['rawname'])) {
92                     unset($tag['rawname']);
93                 }
94             }
95             if (!$canmanage) {
96                 // User without manage capability can not change any fields except for descriptions.
97                 $tag = array_intersect_key($tag, array('id' => 1,
98                     'description' => 1, 'descriptionformat' => 1));
99             }
100             if (!$canedit) {
101                 // User without edit capability can not change description.
102                 $tag = array_diff_key($tag,
103                         array('description' => 1, 'descriptionformat' => 1));
104             }
105             if (count($tag) <= 1) {
106                 $warnings[] = array(
107                     'item' => $tag['id'],
108                     'warningcode' => 'nothingtoupdate',
109                     'message' => get_string('nothingtoupdate', 'core_tag')
110                 );
111                 continue;
112             }
113             if (!$tagobject = core_tag_tag::get($tag['id'], '*')) {
114                 $warnings[] = array(
115                     'item' => $tag['id'],
116                     'warningcode' => 'tagnotfound',
117                     'message' => get_string('tagnotfound', 'error')
118                 );
119                 continue;
120             }
121             // First check if new tag name is allowed.
122             if (!empty($tag['rawname']) && ($existing = core_tag_tag::get_by_name($tagobject->tagcollid, $tag['rawname']))) {
123                 if ($existing->id != $tag['id']) {
124                     $warnings[] = array(
125                         'item' => $tag['id'],
126                         'warningcode' => 'namesalreadybeeingused',
127                         'message' => get_string('namesalreadybeeingused', 'core_tag')
128                     );
129                     continue;
130                 }
131             }
132             if (array_key_exists('official', $tag)) {
133                 // Parameter 'official' deprecated and replaced with 'isstandard'.
134                 $tag['isstandard'] = $tag['official'] ? 1 : 0;
135                 unset($tag['official']);
136             }
137             if (isset($tag['flag'])) {
138                 if ($tag['flag']) {
139                     $tagobject->flag();
140                 } else {
141                     $tagobject->reset_flag();
142                 }
143                 unset($tag['flag']);
144             }
145             unset($tag['id']);
146             if (count($tag)) {
147                 $tagobject->update($tag);
148             }
149         }
150         return array('warnings' => $warnings);
151     }
153     /**
154      * Return structure for update_tag()
155      *
156      * @return external_description
157      */
158     public static function update_tags_returns() {
159         return new external_single_structure(
160             array(
161                 'warnings' => new external_warnings()
162             )
163         );
164     }
166     /**
167      * Parameters for function get_tags()
168      *
169      * @return external_function_parameters
170      */
171     public static function get_tags_parameters() {
172         return new external_function_parameters(
173             array(
174                 'tags' => new external_multiple_structure(
175                     new external_single_structure(
176                         array(
177                             'id' => new external_value(PARAM_INT, 'tag id'),
178                         )
179                     )
180                 )
181             )
182         );
183     }
185     /**
186      * Get tags by their ids
187      *
188      * @param array $tags
189      */
190     public static function get_tags($tags) {
191         global $CFG, $PAGE, $DB;
193         // Validate and normalize parameters.
194         $tags = self::validate_parameters(self::get_tags_parameters(), array('tags' => $tags));
196         $systemcontext = context_system::instance();
197         self::validate_context($systemcontext);
199         $canmanage = has_capability('moodle/tag:manage', $systemcontext);
200         $canedit = has_capability('moodle/tag:edit', $systemcontext);
202         $return = array();
203         $warnings = array();
205         if (empty($CFG->usetags)) {
206             throw new moodle_exception('tagsaredisabled', 'tag');
207         }
209         $renderer = $PAGE->get_renderer('core');
210         foreach ($tags['tags'] as $tag) {
211             $tag = (array)$tag;
212             if (!$tagobject = $DB->get_record('tag', array('id' => $tag['id']))) {
213                 $warnings[] = array(
214                     'item' => $tag['id'],
215                     'warningcode' => 'tagnotfound',
216                     'message' => get_string('tagnotfound', 'error')
217                 );
218                 continue;
219             }
220             $tagoutput = new \core_tag\output\tag($tagobject);
221             // Do not return some information to users without permissions.
222             $rv = $tagoutput->export_for_template($renderer);
223             if (!$canmanage) {
224                 if (!$canedit) {
225                     unset($rv->isstandard);
226                     unset($rv->official);
227                 }
228                 unset($rv->flag);
229             }
230             $return[] = $rv;
231         }
232         return array('tags' => $return, 'warnings' => $warnings);
233     }
235     /**
236      * Return structure for get_tag()
237      *
238      * @return external_description
239      */
240     public static function get_tags_returns() {
241         return new external_single_structure(
242             array(
243                 'tags' => new external_multiple_structure( new external_single_structure(
244                     array(
245                         'id' => new external_value(PARAM_INT, 'tag id'),
246                         'tagcollid' => new external_value(PARAM_INT, 'tag collection id'),
247                         'name' => new external_value(PARAM_TAG, 'name'),
248                         'rawname' => new external_value(PARAM_RAW, 'tag raw name (may contain capital letters)'),
249                         'description' => new external_value(PARAM_RAW, 'tag description'),
250                         'descriptionformat' => new external_format_value(PARAM_INT, 'tag description format'),
251                         'flag' => new external_value(PARAM_INT, 'flag', VALUE_OPTIONAL),
252                         'official' => new external_value(PARAM_INT,
253                             'whether this flag is standard (deprecated, use isstandard)', VALUE_OPTIONAL),
254                         'isstandard' => new external_value(PARAM_INT, 'whether this flag is standard', VALUE_OPTIONAL),
255                         'viewurl' => new external_value(PARAM_URL, 'URL to view'),
256                     ), 'information about one tag')
257                 ),
258                 'warnings' => new external_warnings()
259             )
260         );
261     }
263     /**
264      * Parameters for function get_tagindex()
265      *
266      * @return external_function_parameters
267      */
268     public static function get_tagindex_parameters() {
269         return new external_function_parameters(
270             array(
271                 'tagindex' => new external_single_structure(array(
272                     'tag' => new external_value(PARAM_TAG, 'tag name'),
273                     'tc' => new external_value(PARAM_INT, 'tag collection id'),
274                     'ta' => new external_value(PARAM_INT, 'tag area id'),
275                     'excl' => new external_value(PARAM_BOOL, 'exlusive mode for this tag area', VALUE_OPTIONAL, 0),
276                     'from' => new external_value(PARAM_INT, 'context id where the link was displayed', VALUE_OPTIONAL, 0),
277                     'ctx' => new external_value(PARAM_INT, 'context id where to search for items', VALUE_OPTIONAL, 0),
278                     'rec' => new external_value(PARAM_INT, 'search in the context recursive', VALUE_OPTIONAL, 1),
279                     'page' => new external_value(PARAM_INT, 'page number (0-based)', VALUE_OPTIONAL, 0),
280                 ), 'parameters')
281             )
282         );
283     }
285     /**
286      * Get tags by their ids
287      *
288      * @param array $params
289      */
290     public static function get_tagindex($params) {
291         global $PAGE;
292         // Validate and normalize parameters.
293         $tagindex = self::validate_parameters(
294                 self::get_tagindex_parameters(), array('tagindex' => $params));
295         $params = $tagindex['tagindex'] + array(
296             'excl' => 0,
297             'from' => 0,
298             'ctx' => 0,
299             'rec' => 1,
300             'page' => 0
301         );
303         // Login to the course / module if applicable.
304         $context = $params['ctx'] ? context::instance_by_id($params['ctx']) : context_system::instance();
305         self::validate_context($context);
307         $tag = core_tag_tag::get_by_name($params['tc'], $params['tag'], '*', MUST_EXIST);
308         $tagareas = core_tag_collection::get_areas($params['tc']);
309         $tagindex = $tag->get_tag_index($tagareas[$params['ta']], $params['excl'], $params['from'],
310                 $params['ctx'], $params['rec'], $params['page']);
311         $renderer = $PAGE->get_renderer('core');
312         return $tagindex->export_for_template($renderer);
313     }
315     /**
316      * Return structure for get_tag()
317      *
318      * @return external_description
319      */
320     public static function get_tagindex_returns() {
321         return new external_single_structure(
322             array(
323                 'tagid' => new external_value(PARAM_INT, 'tag id'),
324                 'ta' => new external_value(PARAM_INT, 'tag area id'),
325                 'component' => new external_value(PARAM_COMPONENT, 'component'),
326                 'itemtype' => new external_value(PARAM_NOTAGS, 'itemtype'),
327                 'nextpageurl' => new external_value(PARAM_URL, 'URL for the next page', VALUE_OPTIONAL),
328                 'prevpageurl' => new external_value(PARAM_URL, 'URL for the next page', VALUE_OPTIONAL),
329                 'exclusiveurl' => new external_value(PARAM_URL, 'URL for exclusive link', VALUE_OPTIONAL),
330                 'exclusivetext' => new external_value(PARAM_TEXT, 'text for exclusive link', VALUE_OPTIONAL),
331                 'title' => new external_value(PARAM_RAW, 'title'),
332                 'content' => new external_value(PARAM_RAW, 'title'),
333                 'hascontent' => new external_value(PARAM_INT, 'whether the content is present'),
334                 'anchor' => new external_value(PARAM_TEXT, 'name of anchor', VALUE_OPTIONAL),
335             ), 'tag index'
336         );
337     }
340     /**
341      * Parameters for function get_tagindex_per_area()
342      *
343      * @return external_function_parameters
344      * @since  Moodle 3.7
345      */
346     public static function get_tagindex_per_area_parameters() {
347         return new external_function_parameters(
348             array(
349                 'tagindex' => new external_single_structure(array(
350                     'id' => new external_value(PARAM_INT, 'tag id', VALUE_OPTIONAL, 0),
351                     'tag' => new external_value(PARAM_TAG, 'tag name', VALUE_OPTIONAL, ''),
352                     'tc' => new external_value(PARAM_INT, 'tag collection id', VALUE_OPTIONAL, 0),
353                     'ta' => new external_value(PARAM_INT, 'tag area id', VALUE_OPTIONAL, 0),
354                     'excl' => new external_value(PARAM_BOOL, 'exlusive mode for this tag area', VALUE_OPTIONAL, 0),
355                     'from' => new external_value(PARAM_INT, 'context id where the link was displayed', VALUE_OPTIONAL, 0),
356                     'ctx' => new external_value(PARAM_INT, 'context id where to search for items', VALUE_OPTIONAL, 0),
357                     'rec' => new external_value(PARAM_INT, 'search in the context recursive', VALUE_OPTIONAL, 1),
358                     'page' => new external_value(PARAM_INT, 'page number (0-based)', VALUE_OPTIONAL, 0),
359                 ), 'parameters')
360             )
361         );
362     }
364     /**
365      * Returns the tag index per multiple areas if requested.
366      *
367      * @param array $params Tag index required information.
368      * @throws moodle_exception
369      * @since  Moodle 3.7
370      */
371     public static function get_tagindex_per_area($params) {
372         global $CFG, $PAGE;
373         // Validate and normalize parameters.
374         $tagindex = self::validate_parameters(
375             self::get_tagindex_per_area_parameters(), array('tagindex' => $params));
376         $params = $tagindex['tagindex'] + array(    // Force defaults.
377             'id' => 0,
378             'tag' => '',
379             'tc' => 0,
380             'ta' => 0,
381             'excl' => 0,
382             'from' => 0,
383             'ctx' => 0,
384             'rec' => 1,
385             'page' => 0,
386         );
388         if (empty($CFG->usetags)) {
389             throw new moodle_exception('tagsaredisabled', 'tag');
390         }
392         if (!empty($params['tag'])) {
393             if (empty($params['tc'])) {
394                 // Tag name specified but tag collection was not. Try to guess it.
395                 $tags = core_tag_tag::guess_by_name($params['tag'], '*');
396                 if (count($tags) > 1) {
397                     // It is in more that one collection, do not display.
398                     throw new moodle_exception('Tag is in more that one collection, please indicate one.');
399                 } else if (count($tags) == 1) {
400                     $tag = reset($tags);
401                 }
402             } else {
403                 if (!$tag = core_tag_tag::get_by_name($params['tc'], $params['tag'], '*')) {
404                     // Not found in collection.
405                     throw new moodle_exception('notagsfound', 'tag');
406                 }
407             }
408         } else if (!empty($params['id'])) {
409             $tag = core_tag_tag::get($params['id'], '*');
410         }
412         if (empty($tag)) {
413             throw new moodle_exception('notagsfound', 'tag');
414         }
416         // Login to the course / module if applicable.
417         $context = !empty($params['ctx']) ? context::instance_by_id($params['ctx']) : context_system::instance();
418         self::validate_context($context);
420         $tag = core_tag_tag::get_by_name($params['tc'], $tag->name, '*', MUST_EXIST);
421         $tagareas = core_tag_collection::get_areas($params['tc']);
422         $tagareaid = $params['ta'];
424          $exclusivemode = 0;
425         // Find all areas in this collection and their items tagged with this tag.
426         if ($tagareaid) {
427             $tagareas = array($tagareas[$tagareaid]);
428         }
429         if (!$tagareaid && count($tagareas) == 1) {
430             // Automatically set "exclusive" mode for tag collection with one tag area only.
431             $params['excl'] = 1;
432         }
434         $renderer = $PAGE->get_renderer('core');
435         $result = array();
436         foreach ($tagareas as $ta) {
437             $tagindex = $tag->get_tag_index($ta, $params['excl'], $params['from'], $params['ctx'], $params['rec'], $params['page']);
438             if (!empty($tagindex->hascontent)) {
439                 $result[] = $tagindex->export_for_template($renderer);
440             }
441         }
442         return $result;
443     }
445     /**
446      * Return structure for get_tagindex_per_area
447      *
448      * @return external_description
449      * @since  Moodle 3.7
450      */
451     public static function get_tagindex_per_area_returns() {
452         return new external_multiple_structure(
453             self::get_tagindex_returns()
454         );
455     }
457     /**
458      * Returns description of get_tag_areas() parameters.
459      *
460      * @return external_function_parameters
461      * @since  Moodle 3.7
462      */
463     public static function get_tag_areas_parameters() {
464         return new external_function_parameters(array());
465     }
467     /**
468      * Retrieves existing tag areas.
469      *
470      * @return array an array of warnings and objects containing the plugin information
471      * @throws moodle_exception
472      * @since  Moodle 3.7
473      */
474     public static function get_tag_areas() {
475         global $CFG, $PAGE;
477         if (empty($CFG->usetags)) {
478             throw new moodle_exception('tagsaredisabled', 'tag');
479         }
481         $context = context_system::instance();
482         self::validate_context($context);
483         $PAGE->set_context($context); // Needed by internal APIs.
484         $output = $PAGE->get_renderer('core');
486         $areas = core_tag_area::get_areas();
487         $exportedareas = array();
488         foreach ($areas as $itemtype => $component) {
489             foreach ($component as $area) {
490                 // Move optional fields not part of the DB table to otherdata.
491                 $locked = false;
492                 if (isset($area->locked)) {
493                     $locked = $area->locked;
494                     unset($area->locked);
495                 }
496                 $exporter = new \core_tag\external\tag_area_exporter($area, array('locked' => $locked));
497                 $exportedareas[] = $exporter->export($output);
498             }
499         }
501         return array(
502             'areas' => $exportedareas,
503             'warnings' => array(),
504         );
505     }
507     /**
508      * Returns description of get_tag_areas() result value.
509      *
510      * @return external_description
511      * @since  Moodle 3.7
512      */
513     public static function get_tag_areas_returns() {
514         return new external_single_structure(
515             array(
516                 'areas' => new external_multiple_structure(
517                     \core_tag\external\tag_area_exporter::get_read_structure()
518                 ),
519                 'warnings' => new external_warnings(),
520             )
521         );
522     }
524     /**
525      * Returns description of get_tag_collections() parameters.
526      *
527      * @return external_function_parameters
528      * @since  Moodle 3.7
529      */
530     public static function get_tag_collections_parameters() {
531         return new external_function_parameters(array());
532     }
534     /**
535      * Retrieves existing tag collections.
536      *
537      * @return array an array of warnings and tag collections
538      * @throws moodle_exception
539      * @since  Moodle 3.7
540      */
541     public static function get_tag_collections() {
542         global $CFG, $PAGE;
544         if (empty($CFG->usetags)) {
545             throw new moodle_exception('tagsaredisabled', 'tag');
546         }
548         $context = context_system::instance();
549         self::validate_context($context);
550         $PAGE->set_context($context); // Needed by internal APIs.
551         $output = $PAGE->get_renderer('core');
553         $collections = core_tag_collection::get_collections();
554         $exportedcollections = array();
555         foreach ($collections as $collection) {
556             $exporter = new \core_tag\external\tag_collection_exporter($collection);
557             $exportedcollections[] = $exporter->export($output);
558         }
560         return array(
561             'collections' => $exportedcollections,
562             'warnings' => array(),
563         );
564     }
566     /**
567      * Returns description of get_tag_collections() result value.
568      *
569      * @return external_description
570      * @since  Moodle 3.7
571      */
572     public static function get_tag_collections_returns() {
573         return new external_single_structure(
574             array(
575                 'collections' => new external_multiple_structure(
576                     \core_tag\external\tag_collection_exporter::get_read_structure()
577                 ),
578                 'warnings' => new external_warnings(),
579             )
580         );
581     }
583     /**
584      * Returns description of get_tag_cloud() parameters.
585      *
586      * @return external_function_parameters
587      * @since  Moodle 3.7
588      */
589     public static function get_tag_cloud_parameters() {
590         return new external_function_parameters(
591             array(
592                 'tagcollid' => new external_value(PARAM_INT, 'Tag collection id.', VALUE_DEFAULT, 0),
593                 'isstandard' => new external_value(PARAM_BOOL, 'Whether to return only standard tags.', VALUE_DEFAULT, false),
594                 'limit' => new external_value(PARAM_INT, 'Maximum number of tags to retrieve.', VALUE_DEFAULT, 150),
595                 'sort' => new external_value(PARAM_ALPHA, 'Sort order for display
596                     (id, name, rawname, count, flag, isstandard, tagcollid).', VALUE_DEFAULT, 'name'),
597                 'search' => new external_value(PARAM_RAW, 'Search string.', VALUE_DEFAULT, ''),
598                 'fromctx' => new external_value(PARAM_INT, 'Context id where this tag cloud is displayed.', VALUE_DEFAULT, 0),
599                 'ctx' => new external_value(PARAM_INT, 'Only retrieve tag instances in this context.', VALUE_DEFAULT, 0),
600                 'rec' => new external_value(PARAM_INT, 'Retrieve tag instances in the $ctx context and it\'s children.',
601                     VALUE_DEFAULT, 1),
602             )
603         );
604     }
606     /**
607      * Retrieves a tag cloud for display.
608      *
609      * @param int $tagcollid tag collection id
610      * @param bool $isstandard return only standard tags
611      * @param int $limit maximum number of tags to retrieve, tags are sorted by the instance count
612      *            descending here regardless of $sort parameter
613      * @param string $sort sort order for display, default 'name' - tags will be sorted after they are retrieved
614      * @param string $search search string
615      * @param int $fromctx context id where this tag cloud is displayed
616      * @param int $ctx only retrieve tag instances in this context
617      * @param int $rec retrieve tag instances in the $ctx context and it's children (default 1)
618      * @return array an array of warnings and tag cloud information and items
619      * @throws moodle_exception
620      * @since  Moodle 3.7
621      */
622     public static function get_tag_cloud($tagcollid = 0, $isstandard = false, $limit = 150, $sort = 'name',
623             $search = '', $fromctx = 0, $ctx = 0, $rec = 1) {
624         global $CFG, $PAGE;
626         $params = self::validate_parameters(self::get_tag_cloud_parameters(),
627             array(
628                 'tagcollid' => $tagcollid,
629                 'isstandard' => $isstandard,
630                 'limit' => $limit,
631                 'sort' => $sort,
632                 'search' => $search,
633                 'fromctx' => $fromctx,
634                 'ctx' => $ctx,
635                 'rec' => $rec,
636             )
637         );
639         if (empty($CFG->usetags)) {
640             throw new moodle_exception('tagsaredisabled', 'tag');
641         }
643         $context = context_system::instance();
644         self::validate_context($context);
645         $PAGE->set_context($context); // Needed by internal APIs.
646         $output = $PAGE->get_renderer('core');
648         $tagcloud = core_tag_collection::get_tag_cloud($params['tagcollid'], $params['isstandard'], $params['limit'],
649             $params['sort'], $params['search'], $params['fromctx'], $params['ctx'], $params['rec']);
651         $result = $tagcloud->export_for_template($output);
652         $result->warnings = array();
654         return (array) $result;
655     }
657     /**
658      * Returns description of get_tag_cloud() result value.
659      *
660      * @return external_description
661      * @since  Moodle 3.7
662      */
663     public static function get_tag_cloud_returns() {
664         return new external_single_structure(
665             array(
666                 'tags' => new external_multiple_structure(
667                     new external_single_structure(
668                         array(
669                             'name' => new external_value(PARAM_TAG, 'Tag name.'),
670                             'viewurl' => new external_value(PARAM_RAW, 'URL to view the tag index.'),
671                             'flag' => new external_value(PARAM_BOOL, 'Whether the tag is flagged as inappropriate.',
672                                 VALUE_OPTIONAL),
673                             'isstandard' => new external_value(PARAM_BOOL, 'Whether is a standard tag or not.', VALUE_OPTIONAL),
674                             'count' => new external_value(PARAM_INT, 'Number of tag instances.', VALUE_OPTIONAL),
675                             'size' => new external_value(PARAM_INT, 'Proportional size to display the tag.', VALUE_OPTIONAL),
676                         ), 'Tags.'
677                     )
678                 ),
679                 'tagscount' => new external_value(PARAM_INT, 'Number of tags returned.'),
680                 'totalcount' => new external_value(PARAM_INT, 'Total count of tags.'),
681                 'warnings' => new external_warnings(),
682             )
683         );
684     }