Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 3.11.x will end 14 Nov 2022 (12 months plus 6 months extension).
  • Bug fixes for security issues in 3.11.x will end 13 Nov 2023 (18 months plus 12 months extension).
  • PHP version: minimum PHP 7.3.0 Note: minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is supported too.

Differences Between: [Versions 311 and 401] [Versions 38 and 311]

   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   * Contains class core_tag_tag
  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   */
  24  
  25  defined('MOODLE_INTERNAL') || die();
  26  
  27  /**
  28   * Represents one tag and also contains lots of useful tag-related methods as static functions.
  29   *
  30   * Tags can be added to any database records.
  31   * $itemtype refers to the DB table name
  32   * $itemid refers to id field in this DB table
  33   * $component is the component that is responsible for the tag instance
  34   * $context is the affected context
  35   *
  36   * BASIC INSTRUCTIONS :
  37   *  - to "tag a blog post" (for example):
  38   *        core_tag_tag::set_item_tags('post', 'core', $blogpost->id, $context, $arrayoftags);
  39   *
  40   *  - to "remove all the tags on a blog post":
  41   *        core_tag_tag::remove_all_item_tags('post', 'core', $blogpost->id);
  42   *
  43   * set_item_tags() will create tags that do not exist yet.
  44   *
  45   * @property-read int $id
  46   * @property-read string $name
  47   * @property-read string $rawname
  48   * @property-read int $tagcollid
  49   * @property-read int $userid
  50   * @property-read int $isstandard
  51   * @property-read string $description
  52   * @property-read int $descriptionformat
  53   * @property-read int $flag 0 if not flagged or positive integer if flagged
  54   * @property-read int $timemodified
  55   *
  56   * @package   core_tag
  57   * @copyright  2015 Marina Glancy
  58   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  59   */
  60  class core_tag_tag {
  61  
  62      /** @var stdClass data about the tag */
  63      protected $record = null;
  64  
  65      /** @var int indicates that both standard and not standard tags can be used (or should be returned) */
  66      const BOTH_STANDARD_AND_NOT = 0;
  67  
  68      /** @var int indicates that only standard tags can be used (or must be returned) */
  69      const STANDARD_ONLY = 1;
  70  
  71      /** @var int indicates that only non-standard tags should be returned - this does not really have use cases, left for BC  */
  72      const NOT_STANDARD_ONLY = -1;
  73  
  74      /** @var int option to hide standard tags when editing item tags */
  75      const HIDE_STANDARD = 2;
  76  
  77      /**
  78       * Constructor. Use functions get(), get_by_name(), etc.
  79       *
  80       * @param stdClass $record
  81       */
  82      protected function __construct($record) {
  83          if (empty($record->id)) {
  84              throw new coding_exception("Record must contain at least field 'id'");
  85          }
  86          $this->record = $record;
  87      }
  88  
  89      /**
  90       * Magic getter
  91       *
  92       * @param string $name
  93       * @return mixed
  94       */
  95      public function __get($name) {
  96          return $this->record->$name;
  97      }
  98  
  99      /**
 100       * Magic isset method
 101       *
 102       * @param string $name
 103       * @return bool
 104       */
 105      public function __isset($name) {
 106          return isset($this->record->$name);
 107      }
 108  
 109      /**
 110       * Converts to object
 111       *
 112       * @return stdClass
 113       */
 114      public function to_object() {
 115          return fullclone($this->record);
 116      }
 117  
 118      /**
 119       * Returns tag name ready to be displayed
 120       *
 121       * @param bool $ashtml (default true) if true will return htmlspecialchars encoded string
 122       * @return string
 123       */
 124      public function get_display_name($ashtml = true) {
 125          return static::make_display_name($this->record, $ashtml);
 126      }
 127  
 128      /**
 129       * Prepares tag name ready to be displayed
 130       *
 131       * @param stdClass|core_tag_tag $tag record from db table tag, must contain properties name and rawname
 132       * @param bool $ashtml (default true) if true will return htmlspecialchars encoded string
 133       * @return string
 134       */
 135      public static function make_display_name($tag, $ashtml = true) {
 136          global $CFG;
 137  
 138          if (empty($CFG->keeptagnamecase)) {
 139              // This is the normalized tag name.
 140              $tagname = core_text::strtotitle($tag->name);
 141          } else {
 142              // Original casing of the tag name.
 143              $tagname = $tag->rawname;
 144          }
 145  
 146          // Clean up a bit just in case the rules change again.
 147          $tagname = clean_param($tagname, PARAM_TAG);
 148  
 149          return $ashtml ? htmlspecialchars($tagname) : $tagname;
 150      }
 151  
 152      /**
 153       * Adds one or more tag in the database.  This function should not be called directly : you should
 154       * use tag_set.
 155       *
 156       * @param   int      $tagcollid
 157       * @param   string|array $tags     one tag, or an array of tags, to be created
 158       * @param   bool     $isstandard type of tag to be created. A standard tag is kept even if there are no records tagged with it.
 159       * @return  array    tag objects indexed by their lowercase normalized names. Any boolean false in the array
 160       *                             indicates an error while adding the tag.
 161       */
 162      protected static function add($tagcollid, $tags, $isstandard = false) {
 163          global $USER, $DB;
 164  
 165          $tagobject = new stdClass();
 166          $tagobject->isstandard   = $isstandard ? 1 : 0;
 167          $tagobject->userid       = $USER->id;
 168          $tagobject->timemodified = time();
 169          $tagobject->tagcollid    = $tagcollid;
 170  
 171          $rv = array();
 172          foreach ($tags as $veryrawname) {
 173              $rawname = clean_param($veryrawname, PARAM_TAG);
 174              if (!$rawname) {
 175                  $rv[$rawname] = false;
 176              } else {
 177                  $obj = (object)(array)$tagobject;
 178                  $obj->rawname = $rawname;
 179                  $obj->name    = core_text::strtolower($rawname);
 180                  $obj->id      = $DB->insert_record('tag', $obj);
 181                  $rv[$obj->name] = new static($obj);
 182  
 183                  \core\event\tag_created::create_from_tag($rv[$obj->name])->trigger();
 184              }
 185          }
 186  
 187          return $rv;
 188      }
 189  
 190      /**
 191       * Simple function to just return a single tag object by its id
 192       *
 193       * @param    int    $id
 194       * @param    string $returnfields which fields do we want returned from table {tag}.
 195       *                        Default value is 'id,name,rawname,tagcollid',
 196       *                        specify '*' to include all fields.
 197       * @param int $strictness IGNORE_MISSING means compatible mode, false returned if record not found, debug message if more found;
 198       *                        IGNORE_MULTIPLE means return first, ignore multiple records found(not recommended);
 199       *                        MUST_EXIST means throw exception if no record or multiple records found
 200       * @return   core_tag_tag|false  tag object
 201       */
 202      public static function get($id, $returnfields = 'id, name, rawname, tagcollid', $strictness = IGNORE_MISSING) {
 203          global $DB;
 204          $record = $DB->get_record('tag', array('id' => $id), $returnfields, $strictness);
 205          if ($record) {
 206              return new static($record);
 207          }
 208          return false;
 209      }
 210  
 211      /**
 212       * Simple function to just return an array of tag objects by their ids
 213       *
 214       * @param    int[]  $ids
 215       * @param    string $returnfields which fields do we want returned from table {tag}.
 216       *                        Default value is 'id,name,rawname,tagcollid',
 217       *                        specify '*' to include all fields.
 218       * @return   core_tag_tag[] array of retrieved tags
 219       */
 220      public static function get_bulk($ids, $returnfields = 'id, name, rawname, tagcollid') {
 221          global $DB;
 222          $result = array();
 223          if (empty($ids)) {
 224              return $result;
 225          }
 226          list($sql, $params) = $DB->get_in_or_equal($ids);
 227          $records = $DB->get_records_select('tag', 'id '.$sql, $params, '', $returnfields);
 228          foreach ($records as $record) {
 229              $result[$record->id] = new static($record);
 230          }
 231          return $result;
 232      }
 233  
 234      /**
 235       * Simple function to just return a single tag object by tagcollid and name
 236       *
 237       * @param int $tagcollid tag collection to use,
 238       *        if 0 is given we will try to guess the tag collection and return the first match
 239       * @param string $name tag name
 240       * @param string $returnfields which fields do we want returned. This is a comma separated string
 241       *         containing any combination of 'id', 'name', 'rawname', 'tagcollid' or '*' to include all fields.
 242       * @param int $strictness IGNORE_MISSING means compatible mode, false returned if record not found, debug message if more found;
 243       *                        IGNORE_MULTIPLE means return first, ignore multiple records found(not recommended);
 244       *                        MUST_EXIST means throw exception if no record or multiple records found
 245       * @return core_tag_tag|false tag object
 246       */
 247      public static function get_by_name($tagcollid, $name, $returnfields='id, name, rawname, tagcollid',
 248                          $strictness = IGNORE_MISSING) {
 249          global $DB;
 250          if ($tagcollid == 0) {
 251              $tags = static::guess_by_name($name, $returnfields);
 252              if ($tags) {
 253                  $tag = reset($tags);
 254                  return $tag;
 255              } else if ($strictness == MUST_EXIST) {
 256                  throw new dml_missing_record_exception('tag', 'name=?', array($name));
 257              }
 258              return false;
 259          }
 260          $name = core_text::strtolower($name);   // To cope with input that might just be wrong case.
 261          $params = array('name' => $name, 'tagcollid' => $tagcollid);
 262          $record = $DB->get_record('tag', $params, $returnfields, $strictness);
 263          if ($record) {
 264              return new static($record);
 265          }
 266          return false;
 267      }
 268  
 269      /**
 270       * Looking in all tag collections for the tag with the given name
 271       *
 272       * @param string $name tag name
 273       * @param string $returnfields
 274       * @return array array of core_tag_tag instances
 275       */
 276      public static function guess_by_name($name, $returnfields='id, name, rawname, tagcollid') {
 277          global $DB;
 278          if (empty($name)) {
 279              return array();
 280          }
 281          $tagcolls = core_tag_collection::get_collections();
 282          list($sql, $params) = $DB->get_in_or_equal(array_keys($tagcolls), SQL_PARAMS_NAMED);
 283          $params['name'] = core_text::strtolower($name);
 284          $tags = $DB->get_records_select('tag', 'name = :name AND tagcollid ' . $sql, $params, '', $returnfields);
 285          if (count($tags) > 1) {
 286              // Sort in the same order as tag collections.
 287              $tagcolls = core_tag_collection::get_collections();
 288              uasort($tags, function($a, $b) use ($tagcolls) {
 289                  return $tagcolls[$a->tagcollid]->sortorder < $tagcolls[$b->tagcollid]->sortorder ? -1 : 1;
 290              });
 291          }
 292          $rv = array();
 293          foreach ($tags as $id => $tag) {
 294              $rv[$id] = new static($tag);
 295          }
 296          return $rv;
 297      }
 298  
 299      /**
 300       * Returns the list of tag objects by tag collection id and the list of tag names
 301       *
 302       * @param    int   $tagcollid
 303       * @param    array $tags array of tags to look for
 304       * @param    string $returnfields list of DB fields to return, must contain 'id', 'name' and 'rawname'
 305       * @return   array tag-indexed array of objects. No value for a key means the tag wasn't found.
 306       */
 307      public static function get_by_name_bulk($tagcollid, $tags, $returnfields = 'id, name, rawname, tagcollid') {
 308          global $DB;
 309  
 310          if (empty($tags)) {
 311              return array();
 312          }
 313  
 314          $cleantags = self::normalize(self::normalize($tags, false)); // Format: rawname => normalised name.
 315  
 316          list($namesql, $params) = $DB->get_in_or_equal(array_values($cleantags));
 317          array_unshift($params, $tagcollid);
 318  
 319          $recordset = $DB->get_recordset_sql("SELECT $returnfields FROM {tag} WHERE tagcollid = ? AND name $namesql", $params);
 320  
 321          $result = array_fill_keys($cleantags, null);
 322          foreach ($recordset as $record) {
 323              $result[$record->name] = new static($record);
 324          }
 325          $recordset->close();
 326          return $result;
 327      }
 328  
 329  
 330      /**
 331       * Function that normalizes a list of tag names.
 332       *
 333       * @param   array        $rawtags array of tags
 334       * @param   bool         $tolowercase convert to lower case?
 335       * @return  array        lowercased normalized tags, indexed by the normalized tag, in the same order as the original array.
 336       *                       (Eg: 'Banana' => 'banana').
 337       */
 338      public static function normalize($rawtags, $tolowercase = true) {
 339          $result = array();
 340          foreach ($rawtags as $rawtag) {
 341              $rawtag = trim($rawtag);
 342              if (strval($rawtag) !== '') {
 343                  $clean = clean_param($rawtag, PARAM_TAG);
 344                  if ($tolowercase) {
 345                      $result[$rawtag] = core_text::strtolower($clean);
 346                  } else {
 347                      $result[$rawtag] = $clean;
 348                  }
 349              }
 350          }
 351          return $result;
 352      }
 353  
 354      /**
 355       * Retrieves tags and/or creates them if do not exist yet
 356       *
 357       * @param int $tagcollid
 358       * @param array $tags array of raw tag names, do not have to be normalised
 359       * @param bool $isstandard create as standard tag (default false)
 360       * @return core_tag_tag[] array of tag objects indexed with lowercase normalised tag name
 361       */
 362      public static function create_if_missing($tagcollid, $tags, $isstandard = false) {
 363          $cleantags = self::normalize(array_filter(self::normalize($tags, false))); // Array rawname => normalised name .
 364  
 365          $result = static::get_by_name_bulk($tagcollid, $tags, '*');
 366          $existing = array_filter($result);
 367          $missing = array_diff_key(array_flip($cleantags), $existing); // Array normalised name => rawname.
 368          if ($missing) {
 369              $newtags = static::add($tagcollid, array_values($missing), $isstandard);
 370              foreach ($newtags as $tag) {
 371                  $result[$tag->name] = $tag;
 372              }
 373          }
 374          return $result;
 375      }
 376  
 377      /**
 378       * Creates a URL to view a tag
 379       *
 380       * @param int $tagcollid
 381       * @param string $name
 382       * @param int $exclusivemode
 383       * @param int $fromctx context id where this tag cloud is displayed
 384       * @param int $ctx context id for tag view link
 385       * @param int $rec recursive argument for tag view link
 386       * @return \moodle_url
 387       */
 388      public static function make_url($tagcollid, $name, $exclusivemode = 0, $fromctx = 0, $ctx = 0, $rec = 1) {
 389          $coll = core_tag_collection::get_by_id($tagcollid);
 390          if (!empty($coll->customurl)) {
 391              $url = '/' . ltrim(trim($coll->customurl), '/');
 392          } else {
 393              $url = '/tag/index.php';
 394          }
 395          $params = array('tc' => $tagcollid, 'tag' => $name);
 396          if ($exclusivemode) {
 397              $params['excl'] = 1;
 398          }
 399          if ($fromctx) {
 400              $params['from'] = $fromctx;
 401          }
 402          if ($ctx) {
 403              $params['ctx'] = $ctx;
 404          }
 405          if (!$rec) {
 406              $params['rec'] = 0;
 407          }
 408          return new moodle_url($url, $params);
 409      }
 410  
 411      /**
 412       * Returns URL to view the tag
 413       *
 414       * @param int $exclusivemode
 415       * @param int $fromctx context id where this tag cloud is displayed
 416       * @param int $ctx context id for tag view link
 417       * @param int $rec recursive argument for tag view link
 418       * @return \moodle_url
 419       */
 420      public function get_view_url($exclusivemode = 0, $fromctx = 0, $ctx = 0, $rec = 1) {
 421          return static::make_url($this->record->tagcollid, $this->record->rawname,
 422              $exclusivemode, $fromctx, $ctx, $rec);
 423      }
 424  
 425      /**
 426       * Validates that the required fields were retrieved and retrieves them if missing
 427       *
 428       * @param array $list array of the fields that need to be validated
 429       * @param string $caller name of the function that requested it, for the debugging message
 430       */
 431      protected function ensure_fields_exist($list, $caller) {
 432          global $DB;
 433          $missing = array_diff($list, array_keys((array)$this->record));
 434          if ($missing) {
 435              debugging('core_tag_tag::' . $caller . '() must be called on fully retrieved tag object. Missing fields: '.
 436                      join(', ', $missing), DEBUG_DEVELOPER);
 437              $this->record = $DB->get_record('tag', array('id' => $this->record->id), '*', MUST_EXIST);
 438          }
 439      }
 440  
 441      /**
 442       * Deletes the tag instance given the record from tag_instance DB table
 443       *
 444       * @param stdClass $taginstance
 445       * @param bool $fullobject whether $taginstance contains all fields from DB table tag_instance
 446       *          (in this case it is safe to add a record snapshot to the event)
 447       * @return bool
 448       */
 449      protected function delete_instance_as_record($taginstance, $fullobject = false) {
 450          global $DB;
 451  
 452          $this->ensure_fields_exist(array('name', 'rawname', 'isstandard'), 'delete_instance_as_record');
 453  
 454          $DB->delete_records('tag_instance', array('id' => $taginstance->id));
 455  
 456          // We can not fire an event with 'null' as the contextid.
 457          if (is_null($taginstance->contextid)) {
 458              $taginstance->contextid = context_system::instance()->id;
 459          }
 460  
 461          // Trigger tag removed event.
 462          $taginstance->tagid = $this->id;
 463          \core\event\tag_removed::create_from_tag_instance($taginstance, $this->name, $this->rawname, $fullobject)->trigger();
 464  
 465          // If there are no other instances of the tag then consider deleting the tag as well.
 466          if (!$this->isstandard) {
 467              if (!$DB->record_exists('tag_instance', array('tagid' => $this->id))) {
 468                  self::delete_tags($this->id);
 469              }
 470          }
 471  
 472          return true;
 473      }
 474  
 475      /**
 476       * Delete one instance of a tag.  If the last instance was deleted, it will also delete the tag, unless it is standard.
 477       *
 478       * @param    string $component component responsible for tagging. For BC it can be empty but in this case the
 479       *                  query will be slow because DB index will not be used.
 480       * @param    string $itemtype the type of the record for which to remove the instance
 481       * @param    int    $itemid   the id of the record for which to remove the instance
 482       * @param    int    $tiuserid tag instance user id, only needed for tag areas with user tagging (such as core/course)
 483       */
 484      protected function delete_instance($component, $itemtype, $itemid, $tiuserid = 0) {
 485          global $DB;
 486          $params = array('tagid' => $this->id,
 487                  'itemtype' => $itemtype, 'itemid' => $itemid);
 488          if ($tiuserid) {
 489              $params['tiuserid'] = $tiuserid;
 490          }
 491          if ($component) {
 492              $params['component'] = $component;
 493          }
 494  
 495          $taginstance = $DB->get_record('tag_instance', $params);
 496          if (!$taginstance) {
 497              return;
 498          }
 499          $this->delete_instance_as_record($taginstance, true);
 500      }
 501  
 502      /**
 503       * Bulk delete all tag instances.
 504       *
 505       * @param stdClass[] $taginstances A list of tag_instance records to delete. Each
 506       *                                 record must also contain the name and rawname
 507       *                                 columns from the related tag record.
 508       */
 509      public static function delete_instances_as_record(array $taginstances) {
 510          global $DB;
 511  
 512          if (empty($taginstances)) {
 513              return;
 514          }
 515  
 516          $taginstanceids = array_map(function($taginstance) {
 517              return $taginstance->id;
 518          }, $taginstances);
 519          // Now remove all the tag instances.
 520          $DB->delete_records_list('tag_instance', 'id', $taginstanceids);
 521          // Save the system context in case the 'contextid' column in the 'tag_instance' table is null.
 522          $syscontextid = context_system::instance()->id;
 523          // Loop through the tag instances and fire an 'tag_removed' event.
 524          foreach ($taginstances as $taginstance) {
 525              // We can not fire an event with 'null' as the contextid.
 526              if (is_null($taginstance->contextid)) {
 527                  $taginstance->contextid = $syscontextid;
 528              }
 529  
 530              // Trigger tag removed event.
 531              \core\event\tag_removed::create_from_tag_instance($taginstance, $taginstance->name,
 532                      $taginstance->rawname, true)->trigger();
 533          }
 534      }
 535  
 536      /**
 537       * Bulk delete all tag instances by tag id.
 538       *
 539       * @param int[] $taginstanceids List of tag instance ids to be deleted.
 540       */
 541      public static function delete_instances_by_id(array $taginstanceids) {
 542          global $DB;
 543  
 544          if (empty($taginstanceids)) {
 545              return;
 546          }
 547  
 548          list($idsql, $params) = $DB->get_in_or_equal($taginstanceids);
 549          $sql = "SELECT ti.*, t.name, t.rawname, t.isstandard
 550                    FROM {tag_instance} ti
 551                    JOIN {tag} t
 552                      ON ti.tagid = t.id
 553                   WHERE ti.id {$idsql}";
 554  
 555          if ($taginstances = $DB->get_records_sql($sql, $params)) {
 556              static::delete_instances_as_record($taginstances);
 557          }
 558      }
 559  
 560      /**
 561       * Bulk delete all tag instances for a component or tag area
 562       *
 563       * @param string $component
 564       * @param string $itemtype (optional)
 565       * @param int $contextid (optional)
 566       */
 567      public static function delete_instances($component, $itemtype = null, $contextid = null) {
 568          global $DB;
 569  
 570          $sql = "SELECT ti.*, t.name, t.rawname, t.isstandard
 571                    FROM {tag_instance} ti
 572                    JOIN {tag} t
 573                      ON ti.tagid = t.id
 574                   WHERE ti.component = :component";
 575          $params = array('component' => $component);
 576          if (!is_null($contextid)) {
 577              $sql .= " AND ti.contextid = :contextid";
 578              $params['contextid'] = $contextid;
 579          }
 580          if (!is_null($itemtype)) {
 581              $sql .= " AND ti.itemtype = :itemtype";
 582              $params['itemtype'] = $itemtype;
 583          }
 584  
 585          if ($taginstances = $DB->get_records_sql($sql, $params)) {
 586              static::delete_instances_as_record($taginstances);
 587          }
 588      }
 589  
 590      /**
 591       * Adds a tag instance
 592       *
 593       * @param string $component
 594       * @param string $itemtype
 595       * @param string $itemid
 596       * @param context $context
 597       * @param int $ordering
 598       * @param int $tiuserid tag instance user id, only needed for tag areas with user tagging (such as core/course)
 599       * @return int id of tag_instance
 600       */
 601      protected function add_instance($component, $itemtype, $itemid, context $context, $ordering, $tiuserid = 0) {
 602          global $DB;
 603          $this->ensure_fields_exist(array('name', 'rawname'), 'add_instance');
 604  
 605          $taginstance = new stdClass;
 606          $taginstance->tagid        = $this->id;
 607          $taginstance->component    = $component ? $component : '';
 608          $taginstance->itemid       = $itemid;
 609          $taginstance->itemtype     = $itemtype;
 610          $taginstance->contextid    = $context->id;
 611          $taginstance->ordering     = $ordering;
 612          $taginstance->timecreated  = time();
 613          $taginstance->timemodified = $taginstance->timecreated;
 614          $taginstance->tiuserid     = $tiuserid;
 615  
 616          $taginstance->id = $DB->insert_record('tag_instance', $taginstance);
 617  
 618          // Trigger tag added event.
 619          \core\event\tag_added::create_from_tag_instance($taginstance, $this->name, $this->rawname, true)->trigger();
 620  
 621          return $taginstance->id;
 622      }
 623  
 624      /**
 625       * Updates the ordering on tag instance
 626       *
 627       * @param int $instanceid
 628       * @param int $ordering
 629       */
 630      protected function update_instance_ordering($instanceid, $ordering) {
 631          global $DB;
 632          $data = new stdClass();
 633          $data->id = $instanceid;
 634          $data->ordering = $ordering;
 635          $data->timemodified = time();
 636  
 637          $DB->update_record('tag_instance', $data);
 638      }
 639  
 640      /**
 641       * Get the array of core_tag_tag objects associated with a list of items.
 642       *
 643       * Use {@link core_tag_tag::get_item_tags_array()} if you wish to get the same data as simple array.
 644       *
 645       * @param string $component component responsible for tagging. For BC it can be empty but in this case the
 646       *               query will be slow because DB index will not be used.
 647       * @param string $itemtype type of the tagged item
 648       * @param int[] $itemids
 649       * @param int $standardonly wether to return only standard tags or any
 650       * @param int $tiuserid tag instance user id, only needed for tag areas with user tagging
 651       * @return core_tag_tag[][] first array key is itemid. For each itemid,
 652       *      an array tagid => tag object with additional fields taginstanceid, taginstancecontextid and ordering
 653       */
 654      public static function get_items_tags($component, $itemtype, $itemids, $standardonly = self::BOTH_STANDARD_AND_NOT,
 655              $tiuserid = 0) {
 656          global $DB;
 657  
 658          if (static::is_enabled($component, $itemtype) === false) {
 659              // Tagging area is properly defined but not enabled - return empty array.
 660              return array();
 661          }
 662  
 663          if (empty($itemids)) {
 664              return array();
 665          }
 666  
 667          $standardonly = (int)$standardonly; // In case somebody passed bool.
 668  
 669          list($idsql, $params) = $DB->get_in_or_equal($itemids, SQL_PARAMS_NAMED);
 670          // Note: if the fields in this query are changed, you need to do the same changes in core_tag_tag::get_correlated_tags().
 671          $sql = "SELECT ti.id AS taginstanceid, tg.id, tg.isstandard, tg.name, tg.rawname, tg.flag,
 672                      tg.tagcollid, ti.ordering, ti.contextid AS taginstancecontextid, ti.itemid
 673                    FROM {tag_instance} ti
 674                    JOIN {tag} tg ON tg.id = ti.tagid
 675                    WHERE ti.itemtype = :itemtype AND ti.itemid $idsql ".
 676                  ($component ? "AND ti.component = :component " : "").
 677                  ($tiuserid ? "AND ti.tiuserid = :tiuserid " : "").
 678                  (($standardonly == self::STANDARD_ONLY) ? "AND tg.isstandard = 1 " : "").
 679                  (($standardonly == self::NOT_STANDARD_ONLY) ? "AND tg.isstandard = 0 " : "").
 680                 "ORDER BY ti.ordering ASC, ti.id";
 681  
 682          $params['itemtype'] = $itemtype;
 683          $params['component'] = $component;
 684          $params['tiuserid'] = $tiuserid;
 685  
 686          $records = $DB->get_records_sql($sql, $params);
 687          $result = array();
 688          foreach ($itemids as $itemid) {
 689              $result[$itemid] = [];
 690          }
 691          foreach ($records as $id => $record) {
 692              $result[$record->itemid][$id] = new static($record);
 693          }
 694          return $result;
 695      }
 696  
 697      /**
 698       * Get the array of core_tag_tag objects associated with an item (instances).
 699       *
 700       * Use {@link core_tag_tag::get_item_tags_array()} if you wish to get the same data as simple array.
 701       *
 702       * @param string $component component responsible for tagging. For BC it can be empty but in this case the
 703       *               query will be slow because DB index will not be used.
 704       * @param string $itemtype type of the tagged item
 705       * @param int $itemid
 706       * @param int $standardonly wether to return only standard tags or any
 707       * @param int $tiuserid tag instance user id, only needed for tag areas with user tagging
 708       * @return core_tag_tag[] each object contains additional fields taginstanceid, taginstancecontextid and ordering
 709       */
 710      public static function get_item_tags($component, $itemtype, $itemid, $standardonly = self::BOTH_STANDARD_AND_NOT,
 711              $tiuserid = 0) {
 712          $tagobjects = static::get_items_tags($component, $itemtype, [$itemid], $standardonly, $tiuserid);
 713          return empty($tagobjects) ? [] : $tagobjects[$itemid];
 714      }
 715  
 716      /**
 717       * Returns the list of display names of the tags that are associated with an item
 718       *
 719       * This method is usually used to prefill the form data for the 'tags' form element
 720       *
 721       * @param string $component component responsible for tagging. For BC it can be empty but in this case the
 722       *               query will be slow because DB index will not be used.
 723       * @param string $itemtype type of the tagged item
 724       * @param int $itemid
 725       * @param int $standardonly wether to return only standard tags or any
 726       * @param int $tiuserid tag instance user id, only needed for tag areas with user tagging
 727       * @param bool $ashtml (default true) if true will return htmlspecialchars encoded tag names
 728       * @return string[] array of tags display names
 729       */
 730      public static function get_item_tags_array($component, $itemtype, $itemid, $standardonly = self::BOTH_STANDARD_AND_NOT,
 731              $tiuserid = 0, $ashtml = true) {
 732          $tags = array();
 733          foreach (static::get_item_tags($component, $itemtype, $itemid, $standardonly, $tiuserid) as $tag) {
 734              $tags[$tag->id] = $tag->get_display_name($ashtml);
 735          }
 736          return $tags;
 737      }
 738  
 739      /**
 740       * Sets the list of tag instances for one item (table record).
 741       *
 742       * Extra exsisting instances are removed, new ones are added. New tags are created if needed.
 743       *
 744       * This method can not be used for setting tags relations, please use set_related_tags()
 745       *
 746       * @param string $component component responsible for tagging
 747       * @param string $itemtype type of the tagged item
 748       * @param int $itemid
 749       * @param context $context
 750       * @param array $tagnames
 751       * @param int $tiuserid tag instance user id, only needed for tag areas with user tagging (such as core/course)
 752       */
 753      public static function set_item_tags($component, $itemtype, $itemid, context $context, $tagnames, $tiuserid = 0) {
 754          if ($itemtype === 'tag') {
 755              if ($tiuserid) {
 756                  throw new coding_exception('Related tags can not have tag instance userid');
 757              }
 758              debugging('You can not use set_item_tags() for tagging a tag, please use set_related_tags()', DEBUG_DEVELOPER);
 759              static::get($itemid, '*', MUST_EXIST)->set_related_tags($tagnames);
 760              return;
 761          }
 762  
 763          if ($tagnames !== null && static::is_enabled($component, $itemtype) === false) {
 764              // Tagging area is properly defined but not enabled - do nothing.
 765              // Unless we are deleting the item tags ($tagnames === null), in which case proceed with deleting.
 766              return;
 767          }
 768  
 769          // Apply clean_param() to all tags.
 770          if ($tagnames) {
 771              $tagcollid = core_tag_area::get_collection($component, $itemtype);
 772              $tagobjects = static::create_if_missing($tagcollid, $tagnames);
 773          } else {
 774              $tagobjects = array();
 775          }
 776  
 777          $allowmultiplecontexts = core_tag_area::allows_tagging_in_multiple_contexts($component, $itemtype);
 778          $currenttags = static::get_item_tags($component, $itemtype, $itemid, self::BOTH_STANDARD_AND_NOT, $tiuserid);
 779          $taginstanceidstomovecontext = [];
 780  
 781          // For data coherence reasons, it's better to remove deleted tags
 782          // before adding new data: ordering could be duplicated.
 783          foreach ($currenttags as $currenttag) {
 784              $hasbeenrequested = array_key_exists($currenttag->name, $tagobjects);
 785              $issamecontext = $currenttag->taginstancecontextid == $context->id;
 786  
 787              if ($allowmultiplecontexts) {
 788                  // If the tag area allows multiple contexts then we should only be
 789                  // managing tags in the given $context. All other tags can be ignored.
 790                  $shoulddelete = $issamecontext && !$hasbeenrequested;
 791              } else {
 792                  // If the tag area only allows tag instances in a single context then
 793                  // all tags that aren't in the requested tags should be deleted, regardless
 794                  // of their context, if they are not part of the new set of tags.
 795                  $shoulddelete = !$hasbeenrequested;
 796                  // If the tag instance isn't in the correct context (legacy data)
 797                  // then we should take this opportunity to update it with the correct
 798                  // context id.
 799                  if (!$shoulddelete && !$issamecontext) {
 800                      $currenttag->taginstancecontextid = $context->id;
 801                      $taginstanceidstomovecontext[] = $currenttag->taginstanceid;
 802                  }
 803              }
 804  
 805              if ($shoulddelete) {
 806                  $taginstance = (object)array('id' => $currenttag->taginstanceid,
 807                      'itemtype' => $itemtype, 'itemid' => $itemid,
 808                      'contextid' => $currenttag->taginstancecontextid, 'tiuserid' => $tiuserid);
 809                  $currenttag->delete_instance_as_record($taginstance, false);
 810              }
 811          }
 812  
 813          if (!empty($taginstanceidstomovecontext)) {
 814              static::change_instances_context($taginstanceidstomovecontext, $context);
 815          }
 816  
 817          $ordering = -1;
 818          foreach ($tagobjects as $name => $tag) {
 819              $ordering++;
 820              foreach ($currenttags as $currenttag) {
 821                  $namesmatch = strval($currenttag->name) === strval($name);
 822  
 823                  if ($allowmultiplecontexts) {
 824                      // If the tag area allows multiple contexts then we should only
 825                      // skip adding a new instance if the existing one is in the correct
 826                      // context.
 827                      $contextsmatch = $currenttag->taginstancecontextid == $context->id;
 828                      $shouldskipinstance = $namesmatch && $contextsmatch;
 829                  } else {
 830                      // The existing behaviour for single context tag areas is to
 831                      // skip adding a new instance regardless of whether the existing
 832                      // instance is in the same context as the provided $context.
 833                      $shouldskipinstance = $namesmatch;
 834                  }
 835  
 836                  if ($shouldskipinstance) {
 837                      if ($currenttag->ordering != $ordering) {
 838                          $currenttag->update_instance_ordering($currenttag->taginstanceid, $ordering);
 839                      }
 840                      continue 2;
 841                  }
 842              }
 843              $tag->add_instance($component, $itemtype, $itemid, $context, $ordering, $tiuserid);
 844          }
 845      }
 846  
 847      /**
 848       * Removes all tags from an item.
 849       *
 850       * All tags will be removed even if tagging is disabled in this area. This is
 851       * usually called when the item itself has been deleted.
 852       *
 853       * @param string $component component responsible for tagging
 854       * @param string $itemtype type of the tagged item
 855       * @param int $itemid
 856       * @param int $tiuserid tag instance user id, only needed for tag areas with user tagging (such as core/course)
 857       */
 858      public static function remove_all_item_tags($component, $itemtype, $itemid, $tiuserid = 0) {
 859          $context = context_system::instance(); // Context will not be used.
 860          static::set_item_tags($component, $itemtype, $itemid, $context, null, $tiuserid);
 861      }
 862  
 863      /**
 864       * Adds a tag to an item, without overwriting the current tags.
 865       *
 866       * If the tag has already been added to the record, no changes are made.
 867       *
 868       * @param string $component the component that was tagged
 869       * @param string $itemtype the type of record to tag ('post' for blogs, 'user' for users, etc.)
 870       * @param int $itemid the id of the record to tag
 871       * @param context $context the context of where this tag was assigned
 872       * @param string $tagname the tag to add
 873       * @param int $tiuserid tag instance user id, only needed for tag areas with user tagging (such as core/course)
 874       * @return int id of tag_instance that was either created or already existed or null if tagging is not enabled
 875       */
 876      public static function add_item_tag($component, $itemtype, $itemid, context $context, $tagname, $tiuserid = 0) {
 877          global $DB;
 878  
 879          if (static::is_enabled($component, $itemtype) === false) {
 880              // Tagging area is properly defined but not enabled - do nothing.
 881              return null;
 882          }
 883  
 884          $rawname = clean_param($tagname, PARAM_TAG);
 885          $normalisedname = core_text::strtolower($rawname);
 886          $tagcollid = core_tag_area::get_collection($component, $itemtype);
 887  
 888          $usersql = $tiuserid ? " AND ti.tiuserid = :tiuserid " : "";
 889          $sql = 'SELECT t.*, ti.id AS taginstanceid
 890                  FROM {tag} t
 891                  LEFT JOIN {tag_instance} ti ON ti.tagid = t.id AND ti.itemtype = :itemtype '.
 892                  $usersql .
 893                  'AND ti.itemid = :itemid AND ti.component = :component
 894                  WHERE t.name = :name AND t.tagcollid = :tagcollid';
 895          $params = array('name' => $normalisedname, 'tagcollid' => $tagcollid, 'itemtype' => $itemtype,
 896              'itemid' => $itemid, 'component' => $component, 'tiuserid' => $tiuserid);
 897          $record = $DB->get_record_sql($sql, $params);
 898          if ($record) {
 899              if ($record->taginstanceid) {
 900                  // Tag was already added to the item, nothing to do here.
 901                  return $record->taginstanceid;
 902              }
 903              $tag = new static($record);
 904          } else {
 905              // The tag does not exist yet, create it.
 906              $tags = static::add($tagcollid, array($tagname));
 907              $tag = reset($tags);
 908          }
 909  
 910          $ordering = $DB->get_field_sql('SELECT MAX(ordering) FROM {tag_instance} ti
 911                  WHERE ti.itemtype = :itemtype AND ti.itemid = :itemid AND
 912                  ti.component = :component' . $usersql, $params);
 913  
 914          return $tag->add_instance($component, $itemtype, $itemid, $context, $ordering + 1, $tiuserid);
 915      }
 916  
 917      /**
 918       * Removes the tag from an item without changing the other tags
 919       *
 920       * @param string $component the component that was tagged
 921       * @param string $itemtype the type of record to tag ('post' for blogs, 'user' for users, etc.)
 922       * @param int $itemid the id of the record to tag
 923       * @param string $tagname the tag to remove
 924       * @param int $tiuserid tag instance user id, only needed for tag areas with user tagging (such as core/course)
 925       */
 926      public static function remove_item_tag($component, $itemtype, $itemid, $tagname, $tiuserid = 0) {
 927          global $DB;
 928  
 929          if (static::is_enabled($component, $itemtype) === false) {
 930              // Tagging area is properly defined but not enabled - do nothing.
 931              return array();
 932          }
 933  
 934          $rawname = clean_param($tagname, PARAM_TAG);
 935          $normalisedname = core_text::strtolower($rawname);
 936  
 937          $usersql = $tiuserid ? " AND tiuserid = :tiuserid " : "";
 938          $componentsql = $component ? " AND ti.component = :component " : "";
 939          $sql = 'SELECT t.*, ti.id AS taginstanceid, ti.contextid AS taginstancecontextid, ti.ordering
 940                  FROM {tag} t JOIN {tag_instance} ti ON ti.tagid = t.id ' . $usersql . '
 941                  WHERE t.name = :name AND ti.itemtype = :itemtype
 942                  AND ti.itemid = :itemid ' . $componentsql;
 943          $params = array('name' => $normalisedname,
 944              'itemtype' => $itemtype, 'itemid' => $itemid, 'component' => $component,
 945              'tiuserid' => $tiuserid);
 946          if ($record = $DB->get_record_sql($sql, $params)) {
 947              $taginstance = (object)array('id' => $record->taginstanceid,
 948                  'itemtype' => $itemtype, 'itemid' => $itemid,
 949                  'contextid' => $record->taginstancecontextid, 'tiuserid' => $tiuserid);
 950              $tag = new static($record);
 951              $tag->delete_instance_as_record($taginstance, false);
 952              $componentsql = $component ? " AND component = :component " : "";
 953              $sql = "UPDATE {tag_instance} SET ordering = ordering - 1
 954                      WHERE itemtype = :itemtype
 955                  AND itemid = :itemid $componentsql $usersql
 956                  AND ordering > :ordering";
 957              $params['ordering'] = $record->ordering;
 958              $DB->execute($sql, $params);
 959          }
 960      }
 961  
 962      /**
 963       * Allows to move all tag instances from one context to another
 964       *
 965       * @param string $component the component that was tagged
 966       * @param string $itemtype the type of record to tag ('post' for blogs, 'user' for users, etc.)
 967       * @param context $oldcontext
 968       * @param context $newcontext
 969       */
 970      public static function move_context($component, $itemtype, $oldcontext, $newcontext) {
 971          global $DB;
 972          if ($oldcontext instanceof context) {
 973              $oldcontext = $oldcontext->id;
 974          }
 975          if ($newcontext instanceof context) {
 976              $newcontext = $newcontext->id;
 977          }
 978          $DB->set_field('tag_instance', 'contextid', $newcontext,
 979                  array('component' => $component, 'itemtype' => $itemtype, 'contextid' => $oldcontext));
 980      }
 981  
 982      /**
 983       * Moves all tags of the specified items to the new context
 984       *
 985       * @param string $component the component that was tagged
 986       * @param string $itemtype the type of record to tag ('post' for blogs, 'user' for users, etc.)
 987       * @param array $itemids
 988       * @param context|int $newcontext target context to move tags to
 989       */
 990      public static function change_items_context($component, $itemtype, $itemids, $newcontext) {
 991          global $DB;
 992          if (empty($itemids)) {
 993              return;
 994          }
 995          if (!is_array($itemids)) {
 996              $itemids = array($itemids);
 997          }
 998          list($sql, $params) = $DB->get_in_or_equal($itemids, SQL_PARAMS_NAMED);
 999          $params['component'] = $component;
1000          $params['itemtype'] = $itemtype;
1001          if ($newcontext instanceof context) {
1002              $newcontext = $newcontext->id;
1003          }
1004  
1005          $DB->set_field_select('tag_instance', 'contextid', $newcontext,
1006              'component = :component AND itemtype = :itemtype AND itemid ' . $sql, $params);
1007      }
1008  
1009      /**
1010       * Moves all of the specified tag instances into a new context.
1011       *
1012       * @param array $taginstanceids The list of tag instance ids that should be moved
1013       * @param context $newcontext The context to move the tag instances into
1014       */
1015      public static function change_instances_context(array $taginstanceids, context $newcontext) {
1016          global $DB;
1017  
1018          if (empty($taginstanceids)) {
1019              return;
1020          }
1021  
1022          list($sql, $params) = $DB->get_in_or_equal($taginstanceids);
1023          $DB->set_field_select('tag_instance', 'contextid', $newcontext->id, "id {$sql}", $params);
1024      }
1025  
1026      /**
1027       * Updates the information about the tag
1028       *
1029       * @param array|stdClass $data data to update, may contain: isstandard, description, descriptionformat, rawname
1030       * @return bool whether the tag was updated. False may be returned if: all new values match the existing,
1031       *         or it was attempted to rename the tag to the name that is already used.
1032       */
1033      public function update($data) {
1034          global $DB, $COURSE;
1035  
1036          $allowedfields = array('isstandard', 'description', 'descriptionformat', 'rawname');
1037  
1038          $data = (array)$data;
1039          if ($extrafields = array_diff(array_keys($data), $allowedfields)) {
1040              debugging('The field(s) '.join(', ', $extrafields).' will be ignored when updating the tag',
1041                      DEBUG_DEVELOPER);
1042          }
1043          $data = array_intersect_key($data, array_fill_keys($allowedfields, 1));
1044          $this->ensure_fields_exist(array_merge(array('tagcollid', 'userid', 'name', 'rawname'), array_keys($data)), 'update');
1045  
1046          // Validate the tag name.
1047          if (array_key_exists('rawname', $data)) {
1048              $data['rawname'] = clean_param($data['rawname'], PARAM_TAG);
1049              $name = core_text::strtolower($data['rawname']);
1050  
1051              if (!$name || $data['rawname'] === $this->rawname) {
1052                  unset($data['rawname']);
1053              } else if ($existing = static::get_by_name($this->tagcollid, $name, 'id')) {
1054                  // Prevent the rename if a tag with that name already exists.
1055                  if ($existing->id != $this->id) {
1056                      throw new moodle_exception('namesalreadybeeingused', 'core_tag');
1057                  }
1058              }
1059              if (isset($data['rawname'])) {
1060                  $data['name'] = $name;
1061              }
1062          }
1063  
1064          // Validate the tag type.
1065          if (array_key_exists('isstandard', $data)) {
1066              $data['isstandard'] = $data['isstandard'] ? 1 : 0;
1067          }
1068  
1069          // Find only the attributes that need to be changed.
1070          $originalname = $this->name;
1071          foreach ($data as $key => $value) {
1072              if ($this->record->$key !== $value) {
1073                  $this->record->$key = $value;
1074              } else {
1075                  unset($data[$key]);
1076              }
1077          }
1078          if (empty($data)) {
1079              return false;
1080          }
1081  
1082          $data['id'] = $this->id;
1083          $data['timemodified'] = time();
1084          $DB->update_record('tag', $data);
1085  
1086          $event = \core\event\tag_updated::create(array(
1087              'objectid' => $this->id,
1088              'relateduserid' => $this->userid,
1089              'context' => context_system::instance(),
1090              'other' => array(
1091                  'name' => $this->name,
1092                  'rawname' => $this->rawname
1093              )
1094          ));
1095          if (isset($data['rawname'])) {
1096              $event->set_legacy_logdata(array($COURSE->id, 'tag', 'update', 'index.php?id='. $this->id,
1097                  $originalname . '->'. $this->name));
1098          }
1099          $event->trigger();
1100          return true;
1101      }
1102  
1103      /**
1104       * Flag a tag as inappropriate
1105       */
1106      public function flag() {
1107          global $DB;
1108  
1109          $this->ensure_fields_exist(array('name', 'userid', 'rawname', 'flag'), 'flag');
1110  
1111          // Update all the tags to flagged.
1112          $this->timemodified = time();
1113          $this->flag++;
1114          $DB->update_record('tag', array('timemodified' => $this->timemodified,
1115              'flag' => $this->flag, 'id' => $this->id));
1116  
1117          $event = \core\event\tag_flagged::create(array(
1118              'objectid' => $this->id,
1119              'relateduserid' => $this->userid,
1120              'context' => context_system::instance(),
1121              'other' => array(
1122                  'name' => $this->name,
1123                  'rawname' => $this->rawname
1124              )
1125  
1126          ));
1127          $event->trigger();
1128      }
1129  
1130      /**
1131       * Remove the inappropriate flag on a tag.
1132       */
1133      public function reset_flag() {
1134          global $DB;
1135  
1136          $this->ensure_fields_exist(array('name', 'userid', 'rawname', 'flag'), 'flag');
1137  
1138          if (!$this->flag) {
1139              // Nothing to do.
1140              return false;
1141          }
1142  
1143          $this->timemodified = time();
1144          $this->flag = 0;
1145          $DB->update_record('tag', array('timemodified' => $this->timemodified,
1146              'flag' => 0, 'id' => $this->id));
1147  
1148          $event = \core\event\tag_unflagged::create(array(
1149              'objectid' => $this->id,
1150              'relateduserid' => $this->userid,
1151              'context' => context_system::instance(),
1152              'other' => array(
1153                  'name' => $this->name,
1154                  'rawname' => $this->rawname
1155              )
1156          ));
1157          $event->trigger();
1158      }
1159  
1160      /**
1161       * Sets the list of tags related to this one.
1162       *
1163       * Tag relations are recorded by two instances linking two tags to each other.
1164       * For tag relations ordering is not used and may be random.
1165       *
1166       * @param array $tagnames
1167       */
1168      public function set_related_tags($tagnames) {
1169          $context = context_system::instance();
1170          $tagobjects = $tagnames ? static::create_if_missing($this->tagcollid, $tagnames) : array();
1171          unset($tagobjects[$this->name]); // Never link to itself.
1172  
1173          $currenttags = static::get_item_tags('core', 'tag', $this->id);
1174  
1175          // For data coherence reasons, it's better to remove deleted tags
1176          // before adding new data: ordering could be duplicated.
1177          foreach ($currenttags as $currenttag) {
1178              if (!array_key_exists($currenttag->name, $tagobjects)) {
1179                  $taginstance = (object)array('id' => $currenttag->taginstanceid,
1180                      'itemtype' => 'tag', 'itemid' => $this->id,
1181                      'contextid' => $context->id);
1182                  $currenttag->delete_instance_as_record($taginstance, false);
1183                  $this->delete_instance('core', 'tag', $currenttag->id);
1184              }
1185          }
1186  
1187          foreach ($tagobjects as $name => $tag) {
1188              foreach ($currenttags as $currenttag) {
1189                  if ($currenttag->name === $name) {
1190                      continue 2;
1191                  }
1192              }
1193              $this->add_instance('core', 'tag', $tag->id, $context, 0);
1194              $tag->add_instance('core', 'tag', $this->id, $context, 0);
1195              $currenttags[] = $tag;
1196          }
1197      }
1198  
1199      /**
1200       * Adds to the list of related tags without removing existing
1201       *
1202       * Tag relations are recorded by two instances linking two tags to each other.
1203       * For tag relations ordering is not used and may be random.
1204       *
1205       * @param array $tagnames
1206       */
1207      public function add_related_tags($tagnames) {
1208          $context = context_system::instance();
1209          $tagobjects = static::create_if_missing($this->tagcollid, $tagnames);
1210  
1211          $currenttags = static::get_item_tags('core', 'tag', $this->id);
1212  
1213          foreach ($tagobjects as $name => $tag) {
1214              foreach ($currenttags as $currenttag) {
1215                  if ($currenttag->name === $name) {
1216                      continue 2;
1217                  }
1218              }
1219              $this->add_instance('core', 'tag', $tag->id, $context, 0);
1220              $tag->add_instance('core', 'tag', $this->id, $context, 0);
1221              $currenttags[] = $tag;
1222          }
1223      }
1224  
1225      /**
1226       * Returns the correlated tags of a tag, retrieved from the tag_correlation table.
1227       *
1228       * Correlated tags are calculated in cron based on existing tag instances.
1229       *
1230       * @param bool $keepduplicates if true, will return one record for each existing
1231       *      tag instance which may result in duplicates of the actual tags
1232       * @return core_tag_tag[] an array of tag objects
1233       */
1234      public function get_correlated_tags($keepduplicates = false) {
1235          global $DB;
1236  
1237          $correlated = $DB->get_field('tag_correlation', 'correlatedtags', array('tagid' => $this->id));
1238  
1239          if (!$correlated) {
1240              return array();
1241          }
1242          $correlated = preg_split('/\s*,\s*/', trim($correlated), -1, PREG_SPLIT_NO_EMPTY);
1243          list($query, $params) = $DB->get_in_or_equal($correlated);
1244  
1245          // This is (and has to) return the same fields as the query in core_tag_tag::get_item_tags().
1246          $sql = "SELECT ti.id AS taginstanceid, tg.id, tg.isstandard, tg.name, tg.rawname, tg.flag,
1247                  tg.tagcollid, ti.ordering, ti.contextid AS taginstancecontextid, ti.itemid
1248                FROM {tag} tg
1249          INNER JOIN {tag_instance} ti ON tg.id = ti.tagid
1250               WHERE tg.id $query AND tg.id <> ? AND tg.tagcollid = ?
1251            ORDER BY ti.ordering ASC, ti.id";
1252          $params[] = $this->id;
1253          $params[] = $this->tagcollid;
1254          $records = $DB->get_records_sql($sql, $params);
1255          $seen = array();
1256          $result = array();
1257          foreach ($records as $id => $record) {
1258              if (!$keepduplicates && !empty($seen[$record->id])) {
1259                  continue;
1260              }
1261              $result[$id] = new static($record);
1262              $seen[$record->id] = true;
1263          }
1264          return $result;
1265      }
1266  
1267      /**
1268       * Returns tags that this tag was manually set as related to
1269       *
1270       * @return core_tag_tag[]
1271       */
1272      public function get_manual_related_tags() {
1273          return self::get_item_tags('core', 'tag', $this->id);
1274      }
1275  
1276      /**
1277       * Returns tags related to a tag
1278       *
1279       * Related tags of a tag come from two sources:
1280       *   - manually added related tags, which are tag_instance entries for that tag
1281       *   - correlated tags, which are calculated
1282       *
1283       * @return core_tag_tag[] an array of tag objects
1284       */
1285      public function get_related_tags() {
1286          $manual = $this->get_manual_related_tags();
1287          $automatic = $this->get_correlated_tags();
1288          $relatedtags = array_merge($manual, $automatic);
1289  
1290          // Remove duplicated tags (multiple instances of the same tag).
1291          $seen = array();
1292          foreach ($relatedtags as $instance => $tag) {
1293              if (isset($seen[$tag->id])) {
1294                  unset($relatedtags[$instance]);
1295              } else {
1296                  $seen[$tag->id] = 1;
1297              }
1298          }
1299  
1300          return $relatedtags;
1301      }
1302  
1303      /**
1304       * Find all items tagged with a tag of a given type ('post', 'user', etc.)
1305       *
1306       * @param    string   $component component responsible for tagging. For BC it can be empty but in this case the
1307       *                    query will be slow because DB index will not be used.
1308       * @param    string   $itemtype  type to restrict search to
1309       * @param    int      $limitfrom (optional, required if $limitnum is set) return a subset of records, starting at this point.
1310       * @param    int      $limitnum  (optional, required if $limitfrom is set) return a subset comprising this many records.
1311       * @param    string   $subquery additional query to be appended to WHERE clause, refer to the itemtable as 'it'
1312       * @param    array    $params additional parameters for the DB query
1313       * @return   array of matching objects, indexed by record id, from the table containing the type requested
1314       */
1315      public function get_tagged_items($component, $itemtype, $limitfrom = '', $limitnum = '', $subquery = '', $params = array()) {
1316          global $DB;
1317  
1318          if (empty($itemtype) || !$DB->get_manager()->table_exists($itemtype)) {
1319              return array();
1320          }
1321          $params = $params ? $params : array();
1322  
1323          $query = "SELECT it.*
1324                      FROM {".$itemtype."} it INNER JOIN {tag_instance} tt ON it.id = tt.itemid
1325                     WHERE tt.itemtype = :itemtype AND tt.tagid = :tagid";
1326          $params['itemtype'] = $itemtype;
1327          $params['tagid'] = $this->id;
1328          if ($component) {
1329              $query .= ' AND tt.component = :component';
1330              $params['component'] = $component;
1331          }
1332          if ($subquery) {
1333              $query .= ' AND ' . $subquery;
1334          }
1335          $query .= ' ORDER BY it.id';
1336  
1337          return $DB->get_records_sql($query, $params, $limitfrom, $limitnum);
1338      }
1339  
1340      /**
1341       * Count how many items are tagged with a specific tag.
1342       *
1343       * @param    string   $component component responsible for tagging. For BC it can be empty but in this case the
1344       *                    query will be slow because DB index will not be used.
1345       * @param    string   $itemtype  type to restrict search to
1346       * @param    string   $subquery additional query to be appended to WHERE clause, refer to the itemtable as 'it'
1347       * @param    array    $params additional parameters for the DB query
1348       * @return   int      number of mathing tags.
1349       */
1350      public function count_tagged_items($component, $itemtype, $subquery = '', $params = array()) {
1351          global $DB;
1352  
1353          if (empty($itemtype) || !$DB->get_manager()->table_exists($itemtype)) {
1354              return 0;
1355          }
1356          $params = $params ? $params : array();
1357  
1358          $query = "SELECT COUNT(it.id)
1359                      FROM {".$itemtype."} it INNER JOIN {tag_instance} tt ON it.id = tt.itemid
1360                     WHERE tt.itemtype = :itemtype AND tt.tagid = :tagid";
1361          $params['itemtype'] = $itemtype;
1362          $params['tagid'] = $this->id;
1363          if ($component) {
1364              $query .= ' AND tt.component = :component';
1365              $params['component'] = $component;
1366          }
1367          if ($subquery) {
1368              $query .= ' AND ' . $subquery;
1369          }
1370  
1371          return $DB->get_field_sql($query, $params);
1372      }
1373  
1374      /**
1375       * Determine if an item is tagged with a specific tag
1376       *
1377       * Note that this is a static method and not a method of core_tag object because the tag might not exist yet,
1378       * for example user searches for "php" and we offer him to add "php" to his interests.
1379       *
1380       * @param   string   $component component responsible for tagging. For BC it can be empty but in this case the
1381       *                   query will be slow because DB index will not be used.
1382       * @param   string   $itemtype    the record type to look for
1383       * @param   int      $itemid      the record id to look for
1384       * @param   string   $tagname     a tag name
1385       * @return  int                   1 if it is tagged, 0 otherwise
1386       */
1387      public static function is_item_tagged_with($component, $itemtype, $itemid, $tagname) {
1388          global $DB;
1389          $tagcollid = core_tag_area::get_collection($component, $itemtype);
1390          $query = 'SELECT 1 FROM {tag} t
1391                      JOIN {tag_instance} ti ON ti.tagid = t.id
1392                      WHERE t.name = ? AND t.tagcollid = ? AND ti.itemtype = ? AND ti.itemid = ?';
1393          $cleanname = core_text::strtolower(clean_param($tagname, PARAM_TAG));
1394          $params = array($cleanname, $tagcollid, $itemtype, $itemid);
1395          if ($component) {
1396              $query .= ' AND ti.component = ?';
1397              $params[] = $component;
1398          }
1399          return $DB->record_exists_sql($query, $params) ? 1 : 0;
1400      }
1401  
1402      /**
1403       * Returns whether the tag area is enabled
1404       *
1405       * @param string $component component responsible for tagging
1406       * @param string $itemtype what is being tagged, for example, 'post', 'course', 'user', etc.
1407       * @return bool|null
1408       */
1409      public static function is_enabled($component, $itemtype) {
1410          return core_tag_area::is_enabled($component, $itemtype);
1411      }
1412  
1413      /**
1414       * Retrieves contents of tag area for the tag/index.php page
1415       *
1416       * @param stdClass $tagarea
1417       * @param bool $exclusivemode if set to true it means that no other entities tagged with this tag
1418       *             are displayed on the page and the per-page limit may be bigger
1419       * @param int $fromctx context id where the link was displayed, may be used by callbacks
1420       *            to display items in the same context first
1421       * @param int $ctx context id where to search for records
1422       * @param bool $rec search in subcontexts as well
1423       * @param int $page 0-based number of page being displayed
1424       * @return \core_tag\output\tagindex
1425       */
1426      public function get_tag_index($tagarea, $exclusivemode, $fromctx, $ctx, $rec, $page = 0) {
1427          global $CFG;
1428          if (!empty($tagarea->callback)) {
1429              if (!empty($tagarea->callbackfile)) {
1430                  require_once($CFG->dirroot . '/' . ltrim($tagarea->callbackfile, '/'));
1431              }
1432              $callback = $tagarea->callback;
1433              return call_user_func_array($callback, [$this, $exclusivemode, $fromctx, $ctx, $rec, $page]);
1434          }
1435          return null;
1436      }
1437  
1438      /**
1439       * Returns formatted description of the tag
1440       *
1441       * @param array $options
1442       * @return string
1443       */
1444      public function get_formatted_description($options = array()) {
1445          $options = empty($options) ? array() : (array)$options;
1446          $options += array('para' => false, 'overflowdiv' => true);
1447          $description = file_rewrite_pluginfile_urls($this->description, 'pluginfile.php',
1448                  context_system::instance()->id, 'tag', 'description', $this->id);
1449          return format_text($description, $this->descriptionformat, $options);
1450      }
1451  
1452      /**
1453       * Returns the list of tag links available for the current user (edit, flag, etc.)
1454       *
1455       * @return array
1456       */
1457      public function get_links() {
1458          global $USER;
1459          $links = array();
1460  
1461          if (!isloggedin() || isguestuser()) {
1462              return $links;
1463          }
1464  
1465          $tagname = $this->get_display_name();
1466          $systemcontext = context_system::instance();
1467  
1468          // Add a link for users to add/remove this from their interests.
1469          if (static::is_enabled('core', 'user') && core_tag_area::get_collection('core', 'user') == $this->tagcollid) {
1470              if (static::is_item_tagged_with('core', 'user', $USER->id, $this->name)) {
1471                  $url = new moodle_url('/tag/user.php', array('action' => 'removeinterest',
1472                      'sesskey' => sesskey(), 'tag' => $this->rawname));
1473                  $links[] = html_writer::link($url, get_string('removetagfrommyinterests', 'tag', $tagname),
1474                          array('class' => 'removefrommyinterests'));
1475              } else {
1476                  $url = new moodle_url('/tag/user.php', array('action' => 'addinterest',
1477                      'sesskey' => sesskey(), 'tag' => $this->rawname));
1478                  $links[] = html_writer::link($url, get_string('addtagtomyinterests', 'tag', $tagname),
1479                          array('class' => 'addtomyinterests'));
1480              }
1481          }
1482  
1483          // Flag as inappropriate link.  Only people with moodle/tag:flag capability.
1484          if (has_capability('moodle/tag:flag', $systemcontext)) {
1485              $url = new moodle_url('/tag/user.php', array('action' => 'flaginappropriate',
1486                  'sesskey' => sesskey(), 'id' => $this->id));
1487              $links[] = html_writer::link($url, get_string('flagasinappropriate', 'tag', $tagname),
1488                          array('class' => 'flagasinappropriate'));
1489          }
1490  
1491          // Edit tag: Only people with moodle/tag:edit capability who either have it as an interest or can manage tags.
1492          if (has_capability('moodle/tag:edit', $systemcontext) ||
1493                  has_capability('moodle/tag:manage', $systemcontext)) {
1494              $url = new moodle_url('/tag/edit.php', array('id' => $this->id));
1495              $links[] = html_writer::link($url, get_string('edittag', 'tag'),
1496                          array('class' => 'edittag'));
1497          }
1498  
1499          return $links;
1500      }
1501  
1502      /**
1503       * Delete one or more tag, and all their instances if there are any left.
1504       *
1505       * @param    int|array    $tagids one tagid (int), or one array of tagids to delete
1506       * @return   bool     true on success, false otherwise
1507       */
1508      public static function delete_tags($tagids) {
1509          global $DB;
1510  
1511          if (!is_array($tagids)) {
1512              $tagids = array($tagids);
1513          }
1514          if (empty($tagids)) {
1515              return;
1516          }
1517  
1518          // Use the tagids to create a select statement to be used later.
1519          list($tagsql, $tagparams) = $DB->get_in_or_equal($tagids);
1520  
1521          // Store the tags and tag instances we are going to delete.
1522          $tags = $DB->get_records_select('tag', 'id ' . $tagsql, $tagparams);
1523          $taginstances = $DB->get_records_select('tag_instance', 'tagid ' . $tagsql, $tagparams);
1524  
1525          // Delete all the tag instances.
1526          $select = 'WHERE tagid ' . $tagsql;
1527          $sql = "DELETE FROM {tag_instance} $select";
1528          $DB->execute($sql, $tagparams);
1529  
1530          // Delete all the tag correlations.
1531          $sql = "DELETE FROM {tag_correlation} $select";
1532          $DB->execute($sql, $tagparams);
1533  
1534          // Delete all the tags.
1535          $select = 'WHERE id ' . $tagsql;
1536          $sql = "DELETE FROM {tag} $select";
1537          $DB->execute($sql, $tagparams);
1538  
1539          // Fire an event that these items were untagged.
1540          if ($taginstances) {
1541              // Save the system context in case the 'contextid' column in the 'tag_instance' table is null.
1542              $syscontextid = context_system::instance()->id;
1543              // Loop through the tag instances and fire a 'tag_removed'' event.
1544              foreach ($taginstances as $taginstance) {
1545                  // We can not fire an event with 'null' as the contextid.
1546                  if (is_null($taginstance->contextid)) {
1547                      $taginstance->contextid = $syscontextid;
1548                  }
1549  
1550                  // Trigger tag removed event.
1551                  \core\event\tag_removed::create_from_tag_instance($taginstance,
1552                      $tags[$taginstance->tagid]->name, $tags[$taginstance->tagid]->rawname,
1553                      true)->trigger();
1554              }
1555          }
1556  
1557          // Fire an event that these tags were deleted.
1558          if ($tags) {
1559              $context = context_system::instance();
1560              foreach ($tags as $tag) {
1561                  // Delete all files associated with this tag.
1562                  $fs = get_file_storage();
1563                  $files = $fs->get_area_files($context->id, 'tag', 'description', $tag->id);
1564                  foreach ($files as $file) {
1565                      $file->delete();
1566                  }
1567  
1568                  // Trigger an event for deleting this tag.
1569                  $event = \core\event\tag_deleted::create(array(
1570                      'objectid' => $tag->id,
1571                      'relateduserid' => $tag->userid,
1572                      'context' => $context,
1573                      'other' => array(
1574                          'name' => $tag->name,
1575                          'rawname' => $tag->rawname
1576                      )
1577                  ));
1578                  $event->add_record_snapshot('tag', $tag);
1579                  $event->trigger();
1580              }
1581          }
1582  
1583          return true;
1584      }
1585  
1586      /**
1587       * Combine together correlated tags of several tags
1588       *
1589       * This is a help method for method combine_tags()
1590       *
1591       * @param core_tag_tag[] $tags
1592       */
1593      protected function combine_correlated_tags($tags) {
1594          global $DB;
1595          $ids = array_map(function($t) {
1596              return $t->id;
1597          }, $tags);
1598  
1599          // Retrieve the correlated tags of this tag and correlated tags of all tags to be merged in one query
1600          // but store them separately. Calculate the list of correlated tags that need to be added to the current.
1601          list($sql, $params) = $DB->get_in_or_equal($ids);
1602          $params[] = $this->id;
1603          $records = $DB->get_records_select('tag_correlation', 'tagid '.$sql.' OR tagid = ?',
1604              $params, '', 'tagid, id, correlatedtags');
1605          $correlated = array();
1606          $mycorrelated = array();
1607          foreach ($records as $record) {
1608              $taglist = preg_split('/\s*,\s*/', trim($record->correlatedtags), -1, PREG_SPLIT_NO_EMPTY);
1609              if ($record->tagid == $this->id) {
1610                  $mycorrelated = $taglist;
1611              } else {
1612                  $correlated = array_merge($correlated, $taglist);
1613              }
1614          }
1615          array_unique($correlated);
1616          // Strip out from $correlated the ids of the tags that are already in $mycorrelated
1617          // or are one of the tags that are going to be combined.
1618          $correlated = array_diff($correlated, [$this->id], $ids, $mycorrelated);
1619  
1620          if (empty($correlated)) {
1621              // Nothing to do, ignore situation when current tag is correlated to one of the merged tags - they will
1622              // be deleted later and get_tag_correlation() will not return them. Next cron will clean everything up.
1623              return;
1624          }
1625  
1626          // Update correlated tags of this tag.
1627          $newcorrelatedlist = join(',', array_merge($mycorrelated, $correlated));
1628          if (isset($records[$this->id])) {
1629              $DB->update_record('tag_correlation', array('id' => $records[$this->id]->id, 'correlatedtags' => $newcorrelatedlist));
1630          } else {
1631              $DB->insert_record('tag_correlation', array('tagid' => $this->id, 'correlatedtags' => $newcorrelatedlist));
1632          }
1633  
1634          // Add this tag to the list of correlated tags of each tag in $correlated.
1635          list($sql, $params) = $DB->get_in_or_equal($correlated);
1636          $records = $DB->get_records_select('tag_correlation', 'tagid '.$sql, $params, '', 'tagid, id, correlatedtags');
1637          foreach ($correlated as $tagid) {
1638              if (isset($records[$tagid])) {
1639                  $newcorrelatedlist = $records[$tagid]->correlatedtags . ',' . $this->id;
1640                  $DB->update_record('tag_correlation', array('id' => $records[$tagid]->id, 'correlatedtags' => $newcorrelatedlist));
1641              } else {
1642                  $DB->insert_record('tag_correlation', array('tagid' => $tagid, 'correlatedtags' => '' . $this->id));
1643              }
1644          }
1645      }
1646  
1647      /**
1648       * Combines several other tags into this one
1649       *
1650       * Combining rules:
1651       * - current tag becomes the "main" one, all instances
1652       *   pointing to other tags are changed to point to it.
1653       * - if any of the tags is standard, the "main" tag becomes standard too
1654       * - all tags except for the current ("main") are deleted, even when they are standard
1655       *
1656       * @param core_tag_tag[] $tags tags to combine into this one
1657       */
1658      public function combine_tags($tags) {
1659          global $DB;
1660  
1661          $this->ensure_fields_exist(array('id', 'tagcollid', 'isstandard', 'name', 'rawname'), 'combine_tags');
1662  
1663          // Retrieve all tag objects, find if there are any standard tags in the set.
1664          $isstandard = false;
1665          $tagstocombine = array();
1666          $ids = array();
1667          $relatedtags = $this->get_manual_related_tags();
1668          foreach ($tags as $tag) {
1669              $tag->ensure_fields_exist(array('id', 'tagcollid', 'isstandard', 'tagcollid', 'name', 'rawname'), 'combine_tags');
1670              if ($tag && $tag->id != $this->id && $tag->tagcollid == $this->tagcollid) {
1671                  $isstandard = $isstandard || $tag->isstandard;
1672                  $tagstocombine[$tag->name] = $tag;
1673                  $ids[] = $tag->id;
1674                  $relatedtags = array_merge($relatedtags, $tag->get_manual_related_tags());
1675              }
1676          }
1677  
1678          if (empty($tagstocombine)) {
1679              // Nothing to do.
1680              return;
1681          }
1682  
1683          // Combine all manually set related tags, exclude itself all the tags it is about to be combined with.
1684          if ($relatedtags) {
1685              $relatedtags = array_map(function($t) {
1686                  return $t->name;
1687              }, $relatedtags);
1688              array_unique($relatedtags);
1689              $relatedtags = array_diff($relatedtags, [$this->name], array_keys($tagstocombine));
1690          }
1691          $this->set_related_tags($relatedtags);
1692  
1693          // Combine all correlated tags, exclude itself all the tags it is about to be combined with.
1694          $this->combine_correlated_tags($tagstocombine);
1695  
1696          // If any of the duplicate tags are standard, mark this one as standard too.
1697          if ($isstandard && !$this->isstandard) {
1698              $this->update(array('isstandard' => 1));
1699          }
1700  
1701          // Go through all instances of each tag that needs to be combined and make them point to this tag instead.
1702          // We go though the list one by one because otherwise looking-for-duplicates logic would be too complicated.
1703          foreach ($tagstocombine as $tag) {
1704              $params = array('tagid' => $tag->id, 'mainid' => $this->id);
1705              $mainsql = 'SELECT ti.*, t.name, t.rawname, tim.id AS alreadyhasmaintag '
1706                      . 'FROM {tag_instance} ti '
1707                      . 'LEFT JOIN {tag} t ON t.id = ti.tagid '
1708                      . 'LEFT JOIN {tag_instance} tim ON ti.component = tim.component AND '
1709                      . '    ti.itemtype = tim.itemtype AND ti.itemid = tim.itemid AND '
1710                      . '    ti.tiuserid = tim.tiuserid AND tim.tagid = :mainid '
1711                      . 'WHERE ti.tagid = :tagid';
1712  
1713              $records = $DB->get_records_sql($mainsql, $params);
1714              foreach ($records as $record) {
1715                  if ($record->alreadyhasmaintag) {
1716                      // Item is tagged with both main tag and the duplicate tag.
1717                      // Remove instance pointing to the duplicate tag.
1718                      $tag->delete_instance_as_record($record, false);
1719                      $sql = "UPDATE {tag_instance} SET ordering = ordering - 1
1720                              WHERE itemtype = :itemtype
1721                          AND itemid = :itemid AND component = :component AND tiuserid = :tiuserid
1722                          AND ordering > :ordering";
1723                      $DB->execute($sql, (array)$record);
1724                  } else {
1725                      // Item is tagged only with duplicate tag but not the main tag.
1726                      // Replace tagid in the instance pointing to the duplicate tag with this tag.
1727                      $DB->update_record('tag_instance', array('id' => $record->id, 'tagid' => $this->id));
1728                      \core\event\tag_removed::create_from_tag_instance($record, $record->name, $record->rawname)->trigger();
1729                      $record->tagid = $this->id;
1730                      \core\event\tag_added::create_from_tag_instance($record, $this->name, $this->rawname)->trigger();
1731                  }
1732              }
1733          }
1734  
1735          // Finally delete all tags that we combined into the current one.
1736          self::delete_tags($ids);
1737      }
1738  
1739      /**
1740       * Retrieve a list of tags that have been used to tag the given $component
1741       * and $itemtype in the provided $contexts.
1742       *
1743       * @param string $component The tag instance component
1744       * @param string $itemtype The tag instance item type
1745       * @param context[] $contexts The list of contexts to look for tag instances in
1746       * @return core_tag_tag[]
1747       */
1748      public static function get_tags_by_area_in_contexts($component, $itemtype, array $contexts) {
1749          global $DB;
1750  
1751          $params = [$component, $itemtype];
1752          $contextids = array_map(function($context) {
1753              return $context->id;
1754          }, $contexts);
1755          list($contextsql, $contextsqlparams) = $DB->get_in_or_equal($contextids);
1756          $params = array_merge($params, $contextsqlparams);
1757  
1758          $subsql = "SELECT DISTINCT t.id
1759                      FROM {tag} t
1760                      JOIN {tag_instance} ti ON t.id = ti.tagid
1761                     WHERE component = ?
1762                     AND itemtype = ?
1763                     AND contextid {$contextsql}";
1764  
1765          $sql = "SELECT tt.*
1766                  FROM ($subsql) tv
1767                  JOIN {tag} tt ON tt.id = tv.id";
1768  
1769          return array_map(function($record) {
1770              return new core_tag_tag($record);
1771          }, $DB->get_records_sql($sql, $params));
1772      }
1773  }