Search moodle.org's
Developer Documentation

See Release Notes
Long Term Support Release

  • Bug fixes for general core bugs in 3.9.x will end* 10 May 2021 (12 months).
  • Bug fixes for security issues in 3.9.x will end* 8 May 2023 (36 months).
  • PHP version: minimum PHP 7.2.0 Note: minimum PHP version has increased since Moodle 3.8. PHP 7.3.x and 7.4.x are supported too.
/mod/wiki/ -> lib.php (source)

Differences Between: [Versions 39 and 310] [Versions 39 and 311] [Versions 39 and 400] [Versions 39 and 401] [Versions 39 and 402] [Versions 39 and 403]

   1  <?php
   2  
   3  // This file is part of Moodle - http://moodle.org/
   4  //
   5  // Moodle is free software: you can redistribute it and/or modify
   6  // it under the terms of the GNU General Public License as published by
   7  // the Free Software Foundation, either version 3 of the License, or
   8  // (at your option) any later version.
   9  //
  10  // Moodle is distributed in the hope that it will be useful,
  11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  // GNU General Public License for more details.
  14  //
  15  // You should have received a copy of the GNU General Public License
  16  // along with Moodle. If not, see <http://www.gnu.org/licenses/>.
  17  
  18  /**
  19   * Library of functions and constants for module wiki
  20   *
  21   * It contains the great majority of functions defined by Moodle
  22   * that are mandatory to develop a module.
  23   *
  24   * @package mod_wiki
  25   * @copyright 2009 Marc Alier, Jordi Piguillem marc.alier@upc.edu
  26   * @copyright 2009 Universitat Politecnica de Catalunya http://www.upc.edu
  27   *
  28   * @author Jordi Piguillem
  29   * @author Marc Alier
  30   * @author David Jimenez
  31   * @author Josep Arus
  32   * @author Kenneth Riba
  33   *
  34   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  35   */
  36  
  37  defined('MOODLE_INTERNAL') || die();
  38  
  39  /**
  40   * Given an object containing all the necessary data,
  41   * (defined by the form in mod.html) this function
  42   * will create a new instance and return the id number
  43   * of the new instance.
  44   *
  45   * @param object $instance An object from the form in mod.html
  46   * @return int The id of the newly inserted wiki record
  47   **/
  48  function wiki_add_instance($wiki) {
  49      global $DB;
  50  
  51      $wiki->timemodified = time();
  52      # May have to add extra stuff in here #
  53      if (empty($wiki->forceformat)) {
  54          $wiki->forceformat = 0;
  55      }
  56  
  57      $id = $DB->insert_record('wiki', $wiki);
  58  
  59      $completiontimeexpected = !empty($wiki->completionexpected) ? $wiki->completionexpected : null;
  60      \core_completion\api::update_completion_date_event($wiki->coursemodule, 'wiki', $id, $completiontimeexpected);
  61  
  62      return $id;
  63  }
  64  
  65  /**
  66   * Given an object containing all the necessary data,
  67   * (defined by the form in mod.html) this function
  68   * will update an existing instance with new data.
  69   *
  70   * @param object $instance An object from the form in mod.html
  71   * @return boolean Success/Fail
  72   **/
  73  function wiki_update_instance($wiki) {
  74      global $DB;
  75  
  76      $wiki->timemodified = time();
  77      $wiki->id = $wiki->instance;
  78      if (empty($wiki->forceformat)) {
  79          $wiki->forceformat = 0;
  80      }
  81  
  82      $completiontimeexpected = !empty($wiki->completionexpected) ? $wiki->completionexpected : null;
  83      \core_completion\api::update_completion_date_event($wiki->coursemodule, 'wiki', $wiki->id, $completiontimeexpected);
  84  
  85      # May have to add extra stuff in here #
  86  
  87      return $DB->update_record('wiki', $wiki);
  88  }
  89  
  90  /**
  91   * Given an ID of an instance of this module,
  92   * this function will permanently delete the instance
  93   * and any data that depends on it.
  94   *
  95   * @param int $id Id of the module instance
  96   * @return boolean Success/Failure
  97   **/
  98  function wiki_delete_instance($id) {
  99      global $DB;
 100  
 101      if (!$wiki = $DB->get_record('wiki', array('id' => $id))) {
 102          return false;
 103      }
 104  
 105      $result = true;
 106  
 107      # Get subwiki information #
 108      $subwikis = $DB->get_records('wiki_subwikis', array('wikiid' => $wiki->id));
 109  
 110      foreach ($subwikis as $subwiki) {
 111          # Get existing links, and delete them #
 112          if (!$DB->delete_records('wiki_links', array('subwikiid' => $subwiki->id), IGNORE_MISSING)) {
 113              $result = false;
 114          }
 115  
 116          # Get existing pages #
 117          if ($pages = $DB->get_records('wiki_pages', array('subwikiid' => $subwiki->id))) {
 118              foreach ($pages as $page) {
 119                  # Get locks, and delete them #
 120                  if (!$DB->delete_records('wiki_locks', array('pageid' => $page->id), IGNORE_MISSING)) {
 121                      $result = false;
 122                  }
 123  
 124                  # Get versions, and delete them #
 125                  if (!$DB->delete_records('wiki_versions', array('pageid' => $page->id), IGNORE_MISSING)) {
 126                      $result = false;
 127                  }
 128              }
 129  
 130              # Delete pages #
 131              if (!$DB->delete_records('wiki_pages', array('subwikiid' => $subwiki->id), IGNORE_MISSING)) {
 132                  $result = false;
 133              }
 134          }
 135  
 136          # Get existing synonyms, and delete them #
 137          if (!$DB->delete_records('wiki_synonyms', array('subwikiid' => $subwiki->id), IGNORE_MISSING)) {
 138              $result = false;
 139          }
 140  
 141          # Delete any subwikis #
 142          if (!$DB->delete_records('wiki_subwikis', array('id' => $subwiki->id), IGNORE_MISSING)) {
 143              $result = false;
 144          }
 145      }
 146  
 147      $cm = get_coursemodule_from_instance('wiki', $id);
 148      \core_completion\api::update_completion_date_event($cm->id, 'wiki', $wiki->id, null);
 149  
 150      # Delete any dependent records here #
 151      if (!$DB->delete_records('wiki', array('id' => $wiki->id))) {
 152          $result = false;
 153      }
 154  
 155      return $result;
 156  }
 157  
 158  /**
 159   * Implements callback to reset course
 160   *
 161   * @param stdClass $data
 162   * @return boolean|array
 163   */
 164  function wiki_reset_userdata($data) {
 165      global $CFG,$DB;
 166      require_once($CFG->dirroot . '/mod/wiki/pagelib.php');
 167      require_once($CFG->dirroot . "/mod/wiki/locallib.php");
 168  
 169      $componentstr = get_string('modulenameplural', 'wiki');
 170      $status = array();
 171  
 172      //get the wiki(s) in this course.
 173      if (!$wikis = $DB->get_records('wiki', array('course' => $data->courseid))) {
 174          return false;
 175      }
 176      if (empty($data->reset_wiki_comments) && empty($data->reset_wiki_tags) && empty($data->reset_wiki_pages)) {
 177          return $status;
 178      }
 179  
 180      foreach ($wikis as $wiki) {
 181          if (!$cm = get_coursemodule_from_instance('wiki', $wiki->id, $data->courseid)) {
 182              continue;
 183          }
 184          $context = context_module::instance($cm->id);
 185  
 186          // Remove tags or all pages.
 187          if (!empty($data->reset_wiki_pages) || !empty($data->reset_wiki_tags)) {
 188  
 189              // Get subwiki information.
 190              $subwikis = wiki_get_subwikis($wiki->id);
 191  
 192              foreach ($subwikis as $subwiki) {
 193                  // Get existing pages.
 194                  if ($pages = wiki_get_page_list($subwiki->id)) {
 195                      // If the wiki page isn't selected then we are only removing tags.
 196                      if (empty($data->reset_wiki_pages)) {
 197                          // Go through each page and delete the tags.
 198                          foreach ($pages as $page) {
 199                              core_tag_tag::remove_all_item_tags('mod_wiki', 'wiki_pages', $page->id);
 200                          }
 201                      } else {
 202                          // Otherwise we are removing pages and tags.
 203                          wiki_delete_pages($context, $pages, $subwiki->id);
 204                      }
 205                  }
 206                  if (!empty($data->reset_wiki_pages)) {
 207                      // Delete any subwikis.
 208                      $DB->delete_records('wiki_subwikis', array('id' => $subwiki->id), IGNORE_MISSING);
 209  
 210                      // Delete any attached files.
 211                      $fs = get_file_storage();
 212                      $fs->delete_area_files($context->id, 'mod_wiki', 'attachments');
 213                  }
 214              }
 215  
 216              if (!empty($data->reset_wiki_pages)) {
 217                  $status[] = array('component' => $componentstr, 'item' => get_string('deleteallpages', 'wiki'),
 218                      'error' => false);
 219              }
 220              if (!empty($data->reset_wiki_tags)) {
 221                  $status[] = array('component' => $componentstr, 'item' => get_string('tagsdeleted', 'wiki'), 'error' => false);
 222              }
 223          }
 224  
 225          // Remove all comments.
 226          if (!empty($data->reset_wiki_comments) || !empty($data->reset_wiki_pages)) {
 227              $DB->delete_records_select('comments', "contextid = ? AND commentarea='wiki_page'", array($context->id));
 228              if (!empty($data->reset_wiki_comments)) {
 229                  $status[] = array('component' => $componentstr, 'item' => get_string('deleteallcomments'), 'error' => false);
 230              }
 231          }
 232      }
 233  
 234      // Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
 235      // See MDL-9367.
 236      shift_course_mod_dates('wiki', array('editbegin', 'editend'), $data->timeshift, $data->courseid);
 237      $status[] = array('component' => $componentstr, 'item' => get_string('datechanged'), 'error' => false);
 238  
 239      return $status;
 240  }
 241  
 242  
 243  function wiki_reset_course_form_definition(&$mform) {
 244      $mform->addElement('header', 'wikiheader', get_string('modulenameplural', 'wiki'));
 245      $mform->addElement('advcheckbox', 'reset_wiki_pages', get_string('deleteallpages', 'wiki'));
 246      $mform->addElement('advcheckbox', 'reset_wiki_tags', get_string('removeallwikitags', 'wiki'));
 247      $mform->addElement('advcheckbox', 'reset_wiki_comments', get_string('deleteallcomments'));
 248  }
 249  
 250  /**
 251   * Indicates API features that the wiki supports.
 252   *
 253   * @uses FEATURE_GROUPS
 254   * @uses FEATURE_GROUPINGS
 255   * @uses FEATURE_MOD_INTRO
 256   * @uses FEATURE_COMPLETION_TRACKS_VIEWS
 257   * @uses FEATURE_COMPLETION_HAS_RULES
 258   * @uses FEATURE_GRADE_HAS_GRADE
 259   * @uses FEATURE_GRADE_OUTCOMES
 260   * @param string $feature
 261   * @return mixed True if yes (some features may use other values)
 262   */
 263  function wiki_supports($feature) {
 264      switch ($feature) {
 265      case FEATURE_GROUPS:
 266          return true;
 267      case FEATURE_GROUPINGS:
 268          return true;
 269      case FEATURE_MOD_INTRO:
 270          return true;
 271      case FEATURE_COMPLETION_TRACKS_VIEWS:
 272          return true;
 273      case FEATURE_GRADE_HAS_GRADE:
 274          return false;
 275      case FEATURE_GRADE_OUTCOMES:
 276          return false;
 277      case FEATURE_RATE:
 278          return false;
 279      case FEATURE_BACKUP_MOODLE2:
 280          return true;
 281      case FEATURE_SHOW_DESCRIPTION:
 282          return true;
 283      case FEATURE_COMMENT:
 284          return true;
 285  
 286      default:
 287          return null;
 288      }
 289  }
 290  
 291  /**
 292   * Given a course and a time, this module should find recent activity
 293   * that has occurred in wiki activities and print it out.
 294   * Return true if there was output, or false is there was none.
 295   *
 296   * @global $CFG
 297   * @global $DB
 298   * @uses CONTEXT_MODULE
 299   * @uses VISIBLEGROUPS
 300   * @param object $course
 301   * @param bool $viewfullnames capability
 302   * @param int $timestart
 303   * @return boolean
 304   **/
 305  function wiki_print_recent_activity($course, $viewfullnames, $timestart) {
 306      global $CFG, $DB, $OUTPUT;
 307  
 308      $sql = "SELECT p.id, p.timemodified, p.subwikiid, sw.wikiid, w.wikimode, sw.userid, sw.groupid
 309              FROM {wiki_pages} p
 310                  JOIN {wiki_subwikis} sw ON sw.id = p.subwikiid
 311                  JOIN {wiki} w ON w.id = sw.wikiid
 312              WHERE p.timemodified > ? AND w.course = ?
 313              ORDER BY p.timemodified ASC";
 314      if (!$pages = $DB->get_records_sql($sql, array($timestart, $course->id))) {
 315          return false;
 316      }
 317      require_once($CFG->dirroot . "/mod/wiki/locallib.php");
 318  
 319      $wikis = array();
 320  
 321      $modinfo = get_fast_modinfo($course);
 322  
 323      $subwikivisible = array();
 324      foreach ($pages as $page) {
 325          if (!isset($subwikivisible[$page->subwikiid])) {
 326              $subwiki = (object)array('id' => $page->subwikiid, 'wikiid' => $page->wikiid,
 327                  'groupid' => $page->groupid, 'userid' => $page->userid);
 328              $wiki = (object)array('id' => $page->wikiid, 'course' => $course->id, 'wikimode' => $page->wikimode);
 329              $subwikivisible[$page->subwikiid] = wiki_user_can_view($subwiki, $wiki);
 330          }
 331          if ($subwikivisible[$page->subwikiid]) {
 332              $wikis[] = $page;
 333          }
 334      }
 335      unset($subwikivisible);
 336      unset($pages);
 337  
 338      if (!$wikis) {
 339          return false;
 340      }
 341      echo $OUTPUT->heading(get_string("updatedwikipages", 'wiki') . ':', 6);
 342      foreach ($wikis as $wiki) {
 343          $cm = $modinfo->instances['wiki'][$wiki->wikiid];
 344          $link = $CFG->wwwroot . '/mod/wiki/view.php?pageid=' . $wiki->id;
 345          print_recent_activity_note($wiki->timemodified, $wiki, $cm->name, $link, false, $viewfullnames);
 346      }
 347  
 348      return true; //  True if anything was printed, otherwise false
 349  }
 350  
 351  /**
 352   * Must return an array of grades for a given instance of this module,
 353   * indexed by user.  It also returns a maximum allowed grade.
 354   *
 355   * Example:
 356   *    $return->grades = array of grades;
 357   *    $return->maxgrade = maximum allowed grade;
 358   *
 359   *    return $return;
 360   *
 361   * @param int $wikiid ID of an instance of this module
 362   * @return mixed Null or object with an array of grades and with the maximum grade
 363   **/
 364  function wiki_grades($wikiid) {
 365      return null;
 366  }
 367  
 368  /**
 369   * @deprecated since Moodle 3.8
 370   */
 371  function wiki_scale_used() {
 372      throw new coding_exception('wiki_scale_used() can not be used anymore. Plugins can implement ' .
 373          '<modname>_scale_used_anywhere, all implementations of <modname>_scale_used are now ignored');
 374  }
 375  
 376  /**
 377   * Checks if scale is being used by any instance of wiki.
 378   * This function was added in 1.9
 379   *
 380   * This is used to find out if scale used anywhere
 381   * @param $scaleid int
 382   * @return boolean True if the scale is used by any wiki
 383   */
 384  function wiki_scale_used_anywhere($scaleid) {
 385      global $DB;
 386  
 387      //if ($scaleid and $DB->record_exists('wiki', array('grade' => -$scaleid))) {
 388      //    return true;
 389      //} else {
 390      //    return false;
 391      //}
 392  
 393      return false;
 394  }
 395  
 396  /**
 397   * file serving callback
 398   *
 399   * @copyright Josep Arus
 400   * @package  mod_wiki
 401   * @category files
 402   * @param stdClass $course course object
 403   * @param stdClass $cm course module object
 404   * @param stdClass $context context object
 405   * @param string $filearea file area
 406   * @param array $args extra arguments
 407   * @param bool $forcedownload whether or not force download
 408   * @param array $options additional options affecting the file serving
 409   * @return bool false if the file was not found, just send the file otherwise and do not return anything
 410   */
 411  function wiki_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
 412      global $CFG;
 413  
 414      if ($context->contextlevel != CONTEXT_MODULE) {
 415          return false;
 416      }
 417  
 418      require_login($course, true, $cm);
 419  
 420      require_once($CFG->dirroot . "/mod/wiki/locallib.php");
 421  
 422      if ($filearea == 'attachments') {
 423          $swid = (int) array_shift($args);
 424  
 425          if (!$subwiki = wiki_get_subwiki($swid)) {
 426              return false;
 427          }
 428  
 429          require_capability('mod/wiki:viewpage', $context);
 430  
 431          $relativepath = implode('/', $args);
 432  
 433          $fullpath = "/$context->id/mod_wiki/attachments/$swid/$relativepath";
 434  
 435          $fs = get_file_storage();
 436          if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
 437              return false;
 438          }
 439  
 440          send_stored_file($file, null, 0, $options);
 441      }
 442  }
 443  
 444  function wiki_search_form($cm, $search = '', $subwiki = null) {
 445      global $CFG, $OUTPUT;
 446  
 447      $output = '<div class="wikisearch">';
 448      $output .= '<form method="post" action="' . $CFG->wwwroot . '/mod/wiki/search.php" style="display:inline">';
 449      $output .= '<fieldset class="invisiblefieldset">';
 450      $output .= '<legend class="accesshide">'. get_string('searchwikis', 'wiki') .'</legend>';
 451      $output .= '<label class="accesshide" for="searchwiki">' . get_string("searchterms", "wiki") . '</label>';
 452      $output .= '<input id="searchwiki" name="searchstring" type="text" size="18" value="' . s($search, true) . '" alt="search" />';
 453      $output .= '<input name="courseid" type="hidden" value="' . $cm->course . '" />';
 454      $output .= '<input name="cmid" type="hidden" value="' . $cm->id . '" />';
 455      if (!empty($subwiki->id)) {
 456          $output .= '<input name="subwikiid" type="hidden" value="' . $subwiki->id . '" />';
 457      }
 458      $output .= '<input name="searchwikicontent" type="hidden" value="1" />';
 459      $output .= '<input value="' . get_string('searchwikis', 'wiki') . '" class="btn btn-secondary" type="submit" />';
 460      $output .= '</fieldset>';
 461      $output .= '</form>';
 462      $output .= '</div>';
 463  
 464      return $output;
 465  }
 466  function wiki_extend_navigation(navigation_node $navref, $course, $module, $cm) {
 467      global $CFG, $PAGE, $USER;
 468  
 469      require_once($CFG->dirroot . '/mod/wiki/locallib.php');
 470  
 471      $context = context_module::instance($cm->id);
 472      $url = $PAGE->url;
 473      $userid = 0;
 474      if ($module->wikimode == 'individual') {
 475          $userid = $USER->id;
 476      }
 477  
 478      if (!$wiki = wiki_get_wiki($cm->instance)) {
 479          return false;
 480      }
 481  
 482      if (!$gid = groups_get_activity_group($cm)) {
 483          $gid = 0;
 484      }
 485      if (!$subwiki = wiki_get_subwiki_by_group($cm->instance, $gid, $userid)) {
 486          return null;
 487      } else {
 488          $swid = $subwiki->id;
 489      }
 490  
 491      $pageid = $url->param('pageid');
 492      $cmid = $url->param('id');
 493      if (empty($pageid) && !empty($cmid)) {
 494          // wiki main page
 495          $page = wiki_get_page_by_title($swid, $wiki->firstpagetitle);
 496          $pageid = $page->id;
 497      }
 498  
 499      if (wiki_can_create_pages($context)) {
 500          $link = new moodle_url('/mod/wiki/create.php', array('action' => 'new', 'swid' => $swid));
 501          $node = $navref->add(get_string('newpage', 'wiki'), $link, navigation_node::TYPE_SETTING);
 502      }
 503  
 504      if (is_numeric($pageid)) {
 505  
 506          if (has_capability('mod/wiki:viewpage', $context)) {
 507              $link = new moodle_url('/mod/wiki/view.php', array('pageid' => $pageid));
 508              $node = $navref->add(get_string('view', 'wiki'), $link, navigation_node::TYPE_SETTING);
 509          }
 510  
 511          if (wiki_user_can_edit($subwiki)) {
 512              $link = new moodle_url('/mod/wiki/edit.php', array('pageid' => $pageid));
 513              $node = $navref->add(get_string('edit', 'wiki'), $link, navigation_node::TYPE_SETTING);
 514          }
 515  
 516          if (has_capability('mod/wiki:viewcomment', $context)) {
 517              $link = new moodle_url('/mod/wiki/comments.php', array('pageid' => $pageid));
 518              $node = $navref->add(get_string('comments', 'wiki'), $link, navigation_node::TYPE_SETTING);
 519          }
 520  
 521          if (has_capability('mod/wiki:viewpage', $context)) {
 522              $link = new moodle_url('/mod/wiki/history.php', array('pageid' => $pageid));
 523              $node = $navref->add(get_string('history', 'wiki'), $link, navigation_node::TYPE_SETTING);
 524          }
 525  
 526          if (has_capability('mod/wiki:viewpage', $context)) {
 527              $link = new moodle_url('/mod/wiki/map.php', array('pageid' => $pageid));
 528              $node = $navref->add(get_string('map', 'wiki'), $link, navigation_node::TYPE_SETTING);
 529          }
 530  
 531          if (has_capability('mod/wiki:viewpage', $context)) {
 532              $link = new moodle_url('/mod/wiki/files.php', array('pageid' => $pageid));
 533              $node = $navref->add(get_string('files', 'wiki'), $link, navigation_node::TYPE_SETTING);
 534          }
 535  
 536          if (has_capability('mod/wiki:managewiki', $context)) {
 537              $link = new moodle_url('/mod/wiki/admin.php', array('pageid' => $pageid));
 538              $node = $navref->add(get_string('admin', 'wiki'), $link, navigation_node::TYPE_SETTING);
 539          }
 540      }
 541  }
 542  /**
 543   * Returns all other caps used in wiki module
 544   *
 545   * @return array
 546   */
 547  function wiki_get_extra_capabilities() {
 548      return array('moodle/comment:view', 'moodle/comment:post', 'moodle/comment:delete');
 549  }
 550  
 551  /**
 552   * Running addtional permission check on plugin, for example, plugins
 553   * may have switch to turn on/off comments option, this callback will
 554   * affect UI display, not like pluginname_comment_validate only throw
 555   * exceptions.
 556   * Capability check has been done in comment->check_permissions(), we
 557   * don't need to do it again here.
 558   *
 559   * @package  mod_wiki
 560   * @category comment
 561   *
 562   * @param stdClass $comment_param {
 563   *              context  => context the context object
 564   *              courseid => int course id
 565   *              cm       => stdClass course module object
 566   *              commentarea => string comment area
 567   *              itemid      => int itemid
 568   * }
 569   * @return array
 570   */
 571  function wiki_comment_permissions($comment_param) {
 572      return array('post'=>true, 'view'=>true);
 573  }
 574  
 575  /**
 576   * Validate comment parameter before perform other comments actions
 577   *
 578   * @param stdClass $comment_param {
 579   *              context  => context the context object
 580   *              courseid => int course id
 581   *              cm       => stdClass course module object
 582   *              commentarea => string comment area
 583   *              itemid      => int itemid
 584   * }
 585   *
 586   * @package  mod_wiki
 587   * @category comment
 588   *
 589   * @return boolean
 590   */
 591  function wiki_comment_validate($comment_param) {
 592      global $DB, $CFG;
 593      require_once($CFG->dirroot . '/mod/wiki/locallib.php');
 594      // validate comment area
 595      if ($comment_param->commentarea != 'wiki_page') {
 596          throw new comment_exception('invalidcommentarea');
 597      }
 598      // validate itemid
 599      if (!$record = $DB->get_record('wiki_pages', array('id'=>$comment_param->itemid))) {
 600          throw new comment_exception('invalidcommentitemid');
 601      }
 602      if (!$subwiki = wiki_get_subwiki($record->subwikiid)) {
 603          throw new comment_exception('invalidsubwikiid');
 604      }
 605      if (!$wiki = wiki_get_wiki_from_pageid($comment_param->itemid)) {
 606          throw new comment_exception('invalidid', 'data');
 607      }
 608      if (!$course = $DB->get_record('course', array('id'=>$wiki->course))) {
 609          throw new comment_exception('coursemisconf');
 610      }
 611      if (!$cm = get_coursemodule_from_instance('wiki', $wiki->id, $course->id)) {
 612          throw new comment_exception('invalidcoursemodule');
 613      }
 614      $context = context_module::instance($cm->id);
 615      // group access
 616      if ($subwiki->groupid) {
 617          $groupmode = groups_get_activity_groupmode($cm, $course);
 618          if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
 619              if (!groups_is_member($subwiki->groupid)) {
 620                  throw new comment_exception('notmemberofgroup');
 621              }
 622          }
 623      }
 624      // validate context id
 625      if ($context->id != $comment_param->context->id) {
 626          throw new comment_exception('invalidcontext');
 627      }
 628      // validation for comment deletion
 629      if (!empty($comment_param->commentid)) {
 630          if ($comment = $DB->get_record('comments', array('id'=>$comment_param->commentid))) {
 631              if ($comment->commentarea != 'wiki_page') {
 632                  throw new comment_exception('invalidcommentarea');
 633              }
 634              if ($comment->contextid != $context->id) {
 635                  throw new comment_exception('invalidcontext');
 636              }
 637              if ($comment->itemid != $comment_param->itemid) {
 638                  throw new comment_exception('invalidcommentitemid');
 639              }
 640          } else {
 641              throw new comment_exception('invalidcommentid');
 642          }
 643      }
 644      return true;
 645  }
 646  
 647  /**
 648   * Return a list of page types
 649   * @param string $pagetype current page type
 650   * @param stdClass $parentcontext Block's parent context
 651   * @param stdClass $currentcontext Current context of block
 652   */
 653  function wiki_page_type_list($pagetype, $parentcontext, $currentcontext) {
 654      $module_pagetype = array(
 655          'mod-wiki-*'=>get_string('page-mod-wiki-x', 'wiki'),
 656          'mod-wiki-view'=>get_string('page-mod-wiki-view', 'wiki'),
 657          'mod-wiki-comments'=>get_string('page-mod-wiki-comments', 'wiki'),
 658          'mod-wiki-history'=>get_string('page-mod-wiki-history', 'wiki'),
 659          'mod-wiki-map'=>get_string('page-mod-wiki-map', 'wiki')
 660      );
 661      return $module_pagetype;
 662  }
 663  
 664  /**
 665   * Mark the activity completed (if required) and trigger the course_module_viewed event.
 666   *
 667   * @param  stdClass $wiki       Wiki object.
 668   * @param  stdClass $course     Course object.
 669   * @param  stdClass $cm         Course module object.
 670   * @param  stdClass $context    Context object.
 671   * @since Moodle 3.1
 672   */
 673  function wiki_view($wiki, $course, $cm, $context) {
 674      // Trigger course_module_viewed event.
 675      $params = array(
 676          'context' => $context,
 677          'objectid' => $wiki->id
 678      );
 679      $event = \mod_wiki\event\course_module_viewed::create($params);
 680      $event->add_record_snapshot('course_modules', $cm);
 681      $event->add_record_snapshot('course', $course);
 682      $event->add_record_snapshot('wiki', $wiki);
 683      $event->trigger();
 684  
 685      // Completion.
 686      $completion = new completion_info($course);
 687      $completion->set_module_viewed($cm);
 688  }
 689  
 690  /**
 691   * Mark the activity completed (if required) and trigger the page_viewed event.
 692   *
 693   * @param  stdClass $wiki       Wiki object.
 694   * @param  stdClass $page       Page object.
 695   * @param  stdClass $course     Course object.
 696   * @param  stdClass $cm         Course module object.
 697   * @param  stdClass $context    Context object.
 698   * @param  int $uid             Optional User ID.
 699   * @param  array $other         Optional Other params: title, wiki ID, group ID, groupanduser, prettyview.
 700   * @param  stdClass $subwiki    Optional Subwiki.
 701   * @since Moodle 3.1
 702   */
 703  function wiki_page_view($wiki, $page, $course, $cm, $context, $uid = null, $other = null, $subwiki = null) {
 704  
 705      // Trigger course_module_viewed event.
 706      $params = array(
 707          'context' => $context,
 708          'objectid' => $page->id
 709      );
 710      if ($uid != null) {
 711          $params['relateduserid'] = $uid;
 712      }
 713      if ($other != null) {
 714          $params['other'] = $other;
 715      }
 716  
 717      $event = \mod_wiki\event\page_viewed::create($params);
 718  
 719      $event->add_record_snapshot('wiki_pages', $page);
 720      $event->add_record_snapshot('course_modules', $cm);
 721      $event->add_record_snapshot('course', $course);
 722      $event->add_record_snapshot('wiki', $wiki);
 723      if ($subwiki != null) {
 724          $event->add_record_snapshot('wiki_subwikis', $subwiki);
 725      }
 726      $event->trigger();
 727  
 728      // Completion.
 729      $completion = new completion_info($course);
 730      $completion->set_module_viewed($cm);
 731  }
 732  
 733  /**
 734   * Check if the module has any update that affects the current user since a given time.
 735   *
 736   * @param  cm_info $cm course module data
 737   * @param  int $from the time to check updates from
 738   * @param  array $filter  if we need to check only specific updates
 739   * @return stdClass an object with the different type of areas indicating if they were updated or not
 740   * @since Moodle 3.2
 741   */
 742  function wiki_check_updates_since(cm_info $cm, $from, $filter = array()) {
 743      global $DB, $CFG;
 744      require_once($CFG->dirroot . '/mod/wiki/locallib.php');
 745  
 746      $updates = new stdClass();
 747      if (!has_capability('mod/wiki:viewpage', $cm->context)) {
 748          return $updates;
 749      }
 750      $updates = course_check_module_updates_since($cm, $from, array('attachments'), $filter);
 751  
 752      // Check only pages updated in subwikis the user can access.
 753      $updates->pages = (object) array('updated' => false);
 754      $wiki = $DB->get_record($cm->modname, array('id' => $cm->instance), '*', MUST_EXIST);
 755      if ($subwikis = wiki_get_visible_subwikis($wiki, $cm, $cm->context)) {
 756          $subwikisids = array();
 757          foreach ($subwikis as $subwiki) {
 758              $subwikisids[] = $subwiki->id;
 759          }
 760          list($subwikissql, $params) = $DB->get_in_or_equal($subwikisids, SQL_PARAMS_NAMED);
 761          $select = 'subwikiid ' . $subwikissql . ' AND (timemodified > :since1 OR timecreated > :since2)';
 762          $params['since1'] = $from;
 763          $params['since2'] = $from;
 764          $pages = $DB->get_records_select('wiki_pages', $select, $params, '', 'id');
 765          if (!empty($pages)) {
 766              $updates->pages->updated = true;
 767              $updates->pages->itemids = array_keys($pages);
 768          }
 769      }
 770      return $updates;
 771  }
 772  
 773  /**
 774   * Get icon mapping for font-awesome.
 775   */
 776  function mod_wiki_get_fontawesome_icon_map() {
 777      return [
 778          'mod_wiki:attachment' => 'fa-paperclip',
 779      ];
 780  }
 781  
 782  /**
 783   * This function receives a calendar event and returns the action associated with it, or null if there is none.
 784   *
 785   * This is used by block_myoverview in order to display the event appropriately. If null is returned then the event
 786   * is not displayed on the block.
 787   *
 788   * @param calendar_event $event
 789   * @param \core_calendar\action_factory $factory
 790   * @param int $userid User id to use for all capability checks, etc. Set to 0 for current user (default).
 791   * @return \core_calendar\local\event\entities\action_interface|null
 792   */
 793  function mod_wiki_core_calendar_provide_event_action(calendar_event $event,
 794                                                      \core_calendar\action_factory $factory,
 795                                                      int $userid = 0) {
 796      global $USER;
 797  
 798      if (!$userid) {
 799          $userid = $USER->id;
 800      }
 801  
 802      $cm = get_fast_modinfo($event->courseid, $userid)->instances['wiki'][$event->instance];
 803  
 804      if (!$cm->uservisible) {
 805          // The module is not visible to the user for any reason.
 806          return null;
 807      }
 808  
 809      $completion = new \completion_info($cm->get_course());
 810  
 811      $completiondata = $completion->get_data($cm, false, $userid);
 812  
 813      if ($completiondata->completionstate != COMPLETION_INCOMPLETE) {
 814          return null;
 815      }
 816  
 817      return $factory->create_instance(
 818          get_string('view'),
 819          new \moodle_url('/mod/wiki/view.php', ['id' => $cm->id]),
 820          1,
 821          true
 822      );
 823  }
 824  
 825  /**
 826   * Sets dynamic information about a course module
 827   *
 828   * This callback is called from cm_info when checking module availability (incl. $cm->uservisible)
 829   *
 830   * Main viewing capability in mod_wiki is 'mod/wiki:viewpage' instead of the expected standardised 'mod/wiki:view'.
 831   * The method cm_info::is_user_access_restricted_by_capability() does not work for wiki, we need to implement
 832   * this callback.
 833   *
 834   * @param cm_info $cm
 835   */
 836  function wiki_cm_info_dynamic(cm_info $cm) {
 837      if (!has_capability('mod/wiki:viewpage', $cm->context, $cm->get_modinfo()->get_user_id())) {
 838          $cm->set_available(false);
 839      }
 840  }