mod/forum/lib.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * @package   mod_forum
  19  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
  20  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  21  */
  22
  23 defined('MOODLE_INTERNAL') || die();
  24
  25 /** Include required files */
  26 require_once(__DIR__ . '/deprecatedlib.php');
  27 require_once($CFG->libdir.'/filelib.php');
  28
  29 /// CONSTANTS ///////////////////////////////////////////////////////////
  30
  31 define('FORUM_MODE_FLATOLDEST', 1);
  32 define('FORUM_MODE_FLATNEWEST', -1);
  33 define('FORUM_MODE_THREADED', 2);
  34 define('FORUM_MODE_NESTED', 3);
  35 define('FORUM_MODE_MODERN', 4);
  36
  37 define('FORUM_CHOOSESUBSCRIBE', 0);
  38 define('FORUM_FORCESUBSCRIBE', 1);
  39 define('FORUM_INITIALSUBSCRIBE', 2);
  40 define('FORUM_DISALLOWSUBSCRIBE',3);
  41
  42 /**
  43  * FORUM_TRACKING_OFF - Tracking is not available for this forum.
  44  */
  45 define('FORUM_TRACKING_OFF', 0);
  46
  47 /**
  48  * FORUM_TRACKING_OPTIONAL - Tracking is based on user preference.
  49  */
  50 define('FORUM_TRACKING_OPTIONAL', 1);
  51
  52 /**
  53  * FORUM_TRACKING_FORCED - Tracking is on, regardless of user setting.
  54  * Treated as FORUM_TRACKING_OPTIONAL if $CFG->forum_allowforcedreadtracking is off.
  55  */
  56 define('FORUM_TRACKING_FORCED', 2);
  57
  58 define('FORUM_MAILED_PENDING', 0);
  59 define('FORUM_MAILED_SUCCESS', 1);
  60 define('FORUM_MAILED_ERROR', 2);
  61
  62 if (!defined('FORUM_CRON_USER_CACHE')) {
  63     /** Defines how many full user records are cached in forum cron. */
  64     define('FORUM_CRON_USER_CACHE', 5000);
  65 }
  66
  67 /**
  68  * FORUM_POSTS_ALL_USER_GROUPS - All the posts in groups where the user is enrolled.
  69  */
  70 define('FORUM_POSTS_ALL_USER_GROUPS', -2);
  71
  72 define('FORUM_DISCUSSION_PINNED', 1);
  73 define('FORUM_DISCUSSION_UNPINNED', 0);
  74
  75 /// STANDARD FUNCTIONS ///////////////////////////////////////////////////////////
  76
  77 /**
  78  * Given an object containing all the necessary data,
  79  * (defined by the form in mod_form.php) this function
  80  * will create a new instance and return the id number
  81  * of the new instance.
  82  *
  83  * @param stdClass $forum add forum instance
  84  * @param mod_forum_mod_form $mform
  85  * @return int intance id
  86  */
  87 function forum_add_instance($forum, $mform = null) {
  88     global $CFG, $DB;
  89
  90     require_once($CFG->dirroot.'/mod/forum/locallib.php');
  91
  92     $forum->timemodified = time();
  93
  94     if (empty($forum->assessed)) {
  95         $forum->assessed = 0;
  96     }
  97
  98     if (empty($forum->ratingtime) or empty($forum->assessed)) {
  99         $forum->assesstimestart  = 0;
 100         $forum->assesstimefinish = 0;
 101     }
 102
 103     $forum->id = $DB->insert_record('forum', $forum);
 104     $modcontext = context_module::instance($forum->coursemodule);
 105
 106     if ($forum->type == 'single') {  // Create related discussion.
 107         $discussion = new stdClass();
 108         $discussion->course        = $forum->course;
 109         $discussion->forum         = $forum->id;
 110         $discussion->name          = $forum->name;
 111         $discussion->assessed      = $forum->assessed;
 112         $discussion->message       = $forum->intro;
 113         $discussion->messageformat = $forum->introformat;
 114         $discussion->messagetrust  = trusttext_trusted(context_course::instance($forum->course));
 115         $discussion->mailnow       = false;
 116         $discussion->groupid       = -1;
 117
 118         $message = '';
 119
 120         $discussion->id = forum_add_discussion($discussion, null, $message);
 121
 122         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
 123             // Ugly hack - we need to copy the files somehow.
 124             $discussion = $DB->get_record('forum_discussions', array('id'=>$discussion->id), '*', MUST_EXIST);
 125             $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
 126
 127             $options = array('subdirs'=>true); // Use the same options as intro field!
 128             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
 129             $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
 130         }
 131     }
 132
 133     forum_update_calendar($forum, $forum->coursemodule);
 134     forum_grade_item_update($forum);
 135
 136     $completiontimeexpected = !empty($forum->completionexpected) ? $forum->completionexpected : null;
 137     \core_completion\api::update_completion_date_event($forum->coursemodule, 'forum', $forum->id, $completiontimeexpected);
 138
 139     return $forum->id;
 140 }
 141
 142 /**
 143  * Handle changes following the creation of a forum instance.
 144  * This function is typically called by the course_module_created observer.
 145  *
 146  * @param object $context the forum context
 147  * @param stdClass $forum The forum object
 148  * @return void
 149  */
 150 function forum_instance_created($context, $forum) {
 151     if ($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) {
 152         $users = \mod_forum\subscriptions::get_potential_subscribers($context, 0, 'u.id, u.email');
 153         foreach ($users as $user) {
 154             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $context);
 155         }
 156     }
 157 }
 158
 159 /**
 160  * Given an object containing all the necessary data,
 161  * (defined by the form in mod_form.php) this function
 162  * will update an existing instance with new data.
 163  *
 164  * @global object
 165  * @param object $forum forum instance (with magic quotes)
 166  * @return bool success
 167  */
 168 function forum_update_instance($forum, $mform) {
 169     global $CFG, $DB, $OUTPUT, $USER;
 170
 171     require_once($CFG->dirroot.'/mod/forum/locallib.php');
 172
 173     $forum->timemodified = time();
 174     $forum->id           = $forum->instance;
 175
 176     if (empty($forum->assessed)) {
 177         $forum->assessed = 0;
 178     }
 179
 180     if (empty($forum->ratingtime) or empty($forum->assessed)) {
 181         $forum->assesstimestart  = 0;
 182         $forum->assesstimefinish = 0;
 183     }
 184
 185     $oldforum = $DB->get_record('forum', array('id'=>$forum->id));
 186
 187     // MDL-3942 - if the aggregation type or scale (i.e. max grade) changes then recalculate the grades for the entire forum
 188     // if  scale changes - do we need to recheck the ratings, if ratings higher than scale how do we want to respond?
 189     // for count and sum aggregation types the grade we check to make sure they do not exceed the scale (i.e. max score) when calculating the grade
 190     if (($oldforum->assessed<>$forum->assessed) or ($oldforum->scale<>$forum->scale)) {
 191         forum_update_grades($forum); // recalculate grades for the forum
 192     }
 193
 194     if ($forum->type == 'single') {  // Update related discussion and post.
 195         $discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id), 'timemodified ASC');
 196         if (!empty($discussions)) {
 197             if (count($discussions) > 1) {
 198                 echo $OUTPUT->notification(get_string('warnformorepost', 'forum'));
 199             }
 200             $discussion = array_pop($discussions);
 201         } else {
 202             // try to recover by creating initial discussion - MDL-16262
 203             $discussion = new stdClass();
 204             $discussion->course          = $forum->course;
 205             $discussion->forum           = $forum->id;
 206             $discussion->name            = $forum->name;
 207             $discussion->assessed        = $forum->assessed;
 208             $discussion->message         = $forum->intro;
 209             $discussion->messageformat   = $forum->introformat;
 210             $discussion->messagetrust    = true;
 211             $discussion->mailnow         = false;
 212             $discussion->groupid         = -1;
 213
 214             $message = '';
 215
 216             forum_add_discussion($discussion, null, $message);
 217
 218             if (! $discussion = $DB->get_record('forum_discussions', array('forum'=>$forum->id))) {
 219                 print_error('cannotadd', 'forum');
 220             }
 221         }
 222         if (! $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost))) {
 223             print_error('cannotfindfirstpost', 'forum');
 224         }
 225
 226         $cm         = get_coursemodule_from_instance('forum', $forum->id);
 227         $modcontext = context_module::instance($cm->id, MUST_EXIST);
 228
 229         $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
 230         $post->subject       = $forum->name;
 231         $post->message       = $forum->intro;
 232         $post->messageformat = $forum->introformat;
 233         $post->messagetrust  = trusttext_trusted($modcontext);
 234         $post->modified      = $forum->timemodified;
 235         $post->userid        = $USER->id;    // MDL-18599, so that current teacher can take ownership of activities.
 236
 237         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
 238             // Ugly hack - we need to copy the files somehow.
 239             $options = array('subdirs'=>true); // Use the same options as intro field!
 240             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
 241         }
 242
 243         \mod_forum\local\entities\post::add_message_counts($post);
 244         $DB->update_record('forum_posts', $post);
 245         $discussion->name = $forum->name;
 246         $DB->update_record('forum_discussions', $discussion);
 247     }
 248
 249     $DB->update_record('forum', $forum);
 250
 251     $modcontext = context_module::instance($forum->coursemodule);
 252     if (($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) && ($oldforum->forcesubscribe <> $forum->forcesubscribe)) {
 253         $users = \mod_forum\subscriptions::get_potential_subscribers($modcontext, 0, 'u.id, u.email', '');
 254         foreach ($users as $user) {
 255             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $modcontext);
 256         }
 257     }
 258
 259     forum_update_calendar($forum, $forum->coursemodule);
 260     forum_grade_item_update($forum);
 261
 262     $completiontimeexpected = !empty($forum->completionexpected) ? $forum->completionexpected : null;
 263     \core_completion\api::update_completion_date_event($forum->coursemodule, 'forum', $forum->id, $completiontimeexpected);
 264
 265     return true;
 266 }
 267
 268
 269 /**
 270  * Given an ID of an instance of this module,
 271  * this function will permanently delete the instance
 272  * and any data that depends on it.
 273  *
 274  * @global object
 275  * @param int $id forum instance id
 276  * @return bool success
 277  */
 278 function forum_delete_instance($id) {
 279     global $DB;
 280
 281     if (!$forum = $DB->get_record('forum', array('id'=>$id))) {
 282         return false;
 283     }
 284     if (!$cm = get_coursemodule_from_instance('forum', $forum->id)) {
 285         return false;
 286     }
 287     if (!$course = $DB->get_record('course', array('id'=>$cm->course))) {
 288         return false;
 289     }
 290
 291     $context = context_module::instance($cm->id);
 292
 293     // now get rid of all files
 294     $fs = get_file_storage();
 295     $fs->delete_area_files($context->id);
 296
 297     $result = true;
 298
 299     \core_completion\api::update_completion_date_event($cm->id, 'forum', $forum->id, null);
 300
 301     // Delete digest and subscription preferences.
 302     $DB->delete_records('forum_digests', array('forum' => $forum->id));
 303     $DB->delete_records('forum_subscriptions', array('forum'=>$forum->id));
 304     $DB->delete_records('forum_discussion_subs', array('forum' => $forum->id));
 305
 306     if ($discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id))) {
 307         foreach ($discussions as $discussion) {
 308             if (!forum_delete_discussion($discussion, true, $course, $cm, $forum)) {
 309                 $result = false;
 310             }
 311         }
 312     }
 313
 314     forum_tp_delete_read_records(-1, -1, -1, $forum->id);
 315
 316     forum_grade_item_delete($forum);
 317
 318     // We must delete the module record after we delete the grade item.
 319     if (!$DB->delete_records('forum', array('id'=>$forum->id))) {
 320         $result = false;
 321     }
 322
 323     return $result;
 324 }
 325
 326
 327 /**
 328  * Indicates API features that the forum supports.
 329  *
 330  * @uses FEATURE_GROUPS
 331  * @uses FEATURE_GROUPINGS
 332  * @uses FEATURE_MOD_INTRO
 333  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
 334  * @uses FEATURE_COMPLETION_HAS_RULES
 335  * @uses FEATURE_GRADE_HAS_GRADE
 336  * @uses FEATURE_GRADE_OUTCOMES
 337  * @param string $feature
 338  * @return mixed True if yes (some features may use other values)
 339  */
 340 function forum_supports($feature) {
 341     switch($feature) {
 342         case FEATURE_GROUPS:                  return true;
 343         case FEATURE_GROUPINGS:               return true;
 344         case FEATURE_MOD_INTRO:               return true;
 345         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
 346         case FEATURE_COMPLETION_HAS_RULES:    return true;
 347         case FEATURE_GRADE_HAS_GRADE:         return true;
 348         case FEATURE_GRADE_OUTCOMES:          return true;
 349         case FEATURE_RATE:                    return true;
 350         case FEATURE_BACKUP_MOODLE2:          return true;
 351         case FEATURE_SHOW_DESCRIPTION:        return true;
 352         case FEATURE_PLAGIARISM:              return true;
 353
 354         default: return null;
 355     }
 356 }
 357
 358
 359 /**
 360  * Obtains the automatic completion state for this forum based on any conditions
 361  * in forum settings.
 362  *
 363  * @global object
 364  * @global object
 365  * @param object $course Course
 366  * @param object $cm Course-module
 367  * @param int $userid User ID
 368  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
 369  * @return bool True if completed, false if not. (If no conditions, then return
 370  *   value depends on comparison type)
 371  */
 372 function forum_get_completion_state($course,$cm,$userid,$type) {
 373     global $CFG,$DB;
 374
 375     // Get forum details
 376     if (!($forum=$DB->get_record('forum',array('id'=>$cm->instance)))) {
 377         throw new Exception("Can't find forum {$cm->instance}");
 378     }
 379
 380     $result=$type; // Default return value
 381
 382     $postcountparams=array('userid'=>$userid,'forumid'=>$forum->id);
 383     $postcountsql="
 384 SELECT
 385     COUNT(1)
 386 FROM
 387     {forum_posts} fp
 388     INNER JOIN {forum_discussions} fd ON fp.discussion=fd.id
 389 WHERE
 390     fp.userid=:userid AND fd.forum=:forumid";
 391
 392     if ($forum->completiondiscussions) {
 393         $value = $forum->completiondiscussions <=
 394                  $DB->count_records('forum_discussions',array('forum'=>$forum->id,'userid'=>$userid));
 395         if ($type == COMPLETION_AND) {
 396             $result = $result && $value;
 397         } else {
 398             $result = $result || $value;
 399         }
 400     }
 401     if ($forum->completionreplies) {
 402         $value = $forum->completionreplies <=
 403                  $DB->get_field_sql( $postcountsql.' AND fp.parent<>0',$postcountparams);
 404         if ($type==COMPLETION_AND) {
 405             $result = $result && $value;
 406         } else {
 407             $result = $result || $value;
 408         }
 409     }
 410     if ($forum->completionposts) {
 411         $value = $forum->completionposts <= $DB->get_field_sql($postcountsql,$postcountparams);
 412         if ($type == COMPLETION_AND) {
 413             $result = $result && $value;
 414         } else {
 415             $result = $result || $value;
 416         }
 417     }
 418
 419     return $result;
 420 }
 421
 422 /**
 423  * Create a message-id string to use in the custom headers of forum notification emails
 424  *
 425  * message-id is used by email clients to identify emails and to nest conversations
 426  *
 427  * @param int $postid The ID of the forum post we are notifying the user about
 428  * @param int $usertoid The ID of the user being notified
 429  * @return string A unique message-id
 430  */
 431 function forum_get_email_message_id($postid, $usertoid) {
 432     return generate_email_messageid(hash('sha256', $postid . 'to' . $usertoid));
 433 }
 434
 435 /**
 436  *
 437  * @param object $course
 438  * @param object $user
 439  * @param object $mod TODO this is not used in this function, refactor
 440  * @param object $forum
 441  * @return object A standard object with 2 variables: info (number of posts for this user) and time (last modified)
 442  */
 443 function forum_user_outline($course, $user, $mod, $forum) {
 444     global $CFG;
 445     require_once("$CFG->libdir/gradelib.php");
 446     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
 447     if (empty($grades->items[0]->grades)) {
 448         $grade = false;
 449     } else {
 450         $grade = reset($grades->items[0]->grades);
 451     }
 452
 453     $count = forum_count_user_posts($forum->id, $user->id);
 454
 455     if ($count && $count->postcount > 0) {
 456         $result = new stdClass();
 457         $result->info = get_string("numposts", "forum", $count->postcount);
 458         $result->time = $count->lastpost;
 459         if ($grade) {
 460             if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {
 461                 $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
 462             } else {
 463                 $result->info = get_string('grade') . ': ' . get_string('hidden', 'grades');
 464             }
 465         }
 466         return $result;
 467     } else if ($grade) {
 468         $result = (object) [
 469             'time' => grade_get_date_for_user_grade($grade, $user),
 470         ];
 471         if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {
 472             $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
 473         } else {
 474             $result->info = get_string('grade') . ': ' . get_string('hidden', 'grades');
 475         }
 476
 477         return $result;
 478     }
 479     return NULL;
 480 }
 481
 482
 483 /**
 484  * @global object
 485  * @global object
 486  * @param object $coure
 487  * @param object $user
 488  * @param object $mod
 489  * @param object $forum
 490  */
 491 function forum_user_complete($course, $user, $mod, $forum) {
 492     global $CFG,$USER, $OUTPUT;
 493     require_once("$CFG->libdir/gradelib.php");
 494
 495     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
 496     if (!empty($grades->items[0]->grades)) {
 497         $grade = reset($grades->items[0]->grades);
 498         if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {
 499             echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
 500             if ($grade->str_feedback) {
 501                 echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
 502             }
 503         } else {
 504             echo $OUTPUT->container(get_string('grade') . ': ' . get_string('hidden', 'grades'));
 505         }
 506     }
 507
 508     if ($posts = forum_get_user_posts($forum->id, $user->id)) {
 509
 510         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $course->id)) {
 511             print_error('invalidcoursemodule');
 512         }
 513         $context = context_module::instance($cm->id);
 514         $discussions = forum_get_user_involved_discussions($forum->id, $user->id);
 515         $posts = array_filter($posts, function($post) use ($discussions) {
 516             return isset($discussions[$post->discussion]);
 517         });
 518         $entityfactory = mod_forum\local\container::get_entity_factory();
 519         $rendererfactory = mod_forum\local\container::get_renderer_factory();
 520         $postrenderer = $rendererfactory->get_posts_renderer();
 521
 522         echo $postrenderer->render(
 523             $USER,
 524             [$forum->id => $entityfactory->get_forum_from_stdclass($forum, $context, $cm, $course)],
 525             array_map(function($discussion) use ($entityfactory) {
 526                 return $entityfactory->get_discussion_from_stdclass($discussion);
 527             }, $discussions),
 528             array_map(function($post) use ($entityfactory) {
 529                 return $entityfactory->get_post_from_stdclass($post);
 530             }, $posts)
 531         );
 532     } else {
 533         echo "<p>".get_string("noposts", "forum")."</p>";
 534     }
 535 }
 536
 537 /**
 538  * @deprecated since Moodle 3.3, when the block_course_overview block was removed.
 539  */
 540 function forum_filter_user_groups_discussions() {
 541     throw new coding_exception('forum_filter_user_groups_discussions() can not be used any more and is obsolete.');
 542 }
 543
 544 /**
 545  * Returns whether the discussion group is visible by the current user or not.
 546  *
 547  * @since Moodle 2.8, 2.7.1, 2.6.4
 548  * @param cm_info $cm The discussion course module
 549  * @param int $discussiongroupid The discussion groupid
 550  * @return bool
 551  */
 552 function forum_is_user_group_discussion(cm_info $cm, $discussiongroupid) {
 553
 554     if ($discussiongroupid == -1 || $cm->effectivegroupmode != SEPARATEGROUPS) {
 555         return true;
 556     }
 557
 558     if (isguestuser()) {
 559         return false;
 560     }
 561
 562     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id)) ||
 563             in_array($discussiongroupid, $cm->get_modinfo()->get_groups($cm->groupingid))) {
 564         return true;
 565     }
 566
 567     return false;
 568 }
 569
 570 /**
 571  * @deprecated since Moodle 3.3, when the block_course_overview block was removed.
 572  */
 573 function forum_print_overview() {
 574     throw new coding_exception('forum_print_overview() can not be used any more and is obsolete.');
 575 }
 576
 577 /**
 578  * Given a course and a date, prints a summary of all the new
 579  * messages posted in the course since that date
 580  *
 581  * @global object
 582  * @global object
 583  * @global object
 584  * @uses CONTEXT_MODULE
 585  * @uses VISIBLEGROUPS
 586  * @param object $course
 587  * @param bool $viewfullnames capability
 588  * @param int $timestart
 589  * @return bool success
 590  */
 591 function forum_print_recent_activity($course, $viewfullnames, $timestart) {
 592     global $CFG, $USER, $DB, $OUTPUT;
 593
 594     // do not use log table if possible, it may be huge and is expensive to join with other tables
 595
 596     $allnamefields = user_picture::fields('u', null, 'duserid');
 597     if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
 598                                               d.timestart, d.timeend, $allnamefields
 599                                          FROM {forum_posts} p
 600                                               JOIN {forum_discussions} d ON d.id = p.discussion
 601                                               JOIN {forum} f             ON f.id = d.forum
 602                                               JOIN {user} u              ON u.id = p.userid
 603                                         WHERE p.created > ? AND f.course = ? AND p.deleted <> 1
 604                                      ORDER BY p.id ASC", array($timestart, $course->id))) { // order by initial posting date
 605          return false;
 606     }
 607
 608     $modinfo = get_fast_modinfo($course);
 609
 610     $groupmodes = array();
 611     $cms    = array();
 612
 613     $strftimerecent = get_string('strftimerecent');
 614
 615     $printposts = array();
 616     foreach ($posts as $post) {
 617         if (!isset($modinfo->instances['forum'][$post->forum])) {
 618             // not visible
 619             continue;
 620         }
 621         $cm = $modinfo->instances['forum'][$post->forum];
 622         if (!$cm->uservisible) {
 623             continue;
 624         }
 625         $context = context_module::instance($cm->id);
 626
 627         if (!has_capability('mod/forum:viewdiscussion', $context)) {
 628             continue;
 629         }
 630
 631         if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
 632           and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
 633             if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
 634                 continue;
 635             }
 636         }
 637
 638         if (!forum_post_is_visible_privately($post, $cm)) {
 639             continue;
 640         }
 641
 642         // Check that the user can see the discussion.
 643         if (forum_is_user_group_discussion($cm, $post->groupid)) {
 644             $printposts[] = $post;
 645         }
 646
 647     }
 648     unset($posts);
 649
 650     if (!$printposts) {
 651         return false;
 652     }
 653
 654     echo $OUTPUT->heading(get_string('newforumposts', 'forum').':', 3);
 655     $list = html_writer::start_tag('ul', ['class' => 'unlist']);
 656
 657     foreach ($printposts as $post) {
 658         $subjectclass = empty($post->parent) ? ' bold' : '';
 659         $authorhidden = forum_is_author_hidden($post, (object) ['type' => $post->forumtype]);
 660
 661         $list .= html_writer::start_tag('li');
 662         $list .= html_writer::start_div('head');
 663         $list .= html_writer::div(userdate_htmltime($post->modified, $strftimerecent), 'date');
 664         if (!$authorhidden) {
 665             $list .= html_writer::div(fullname($post, $viewfullnames), 'name');
 666         }
 667         $list .= html_writer::end_div(); // Head.
 668
 669         $list .= html_writer::start_div('info' . $subjectclass);
 670         $discussionurl = new moodle_url('/mod/forum/discuss.php', ['d' => $post->discussion]);
 671         if (!empty($post->parent)) {
 672             $discussionurl->param('parent', $post->parent);
 673             $discussionurl->set_anchor('p'. $post->id);
 674         }
 675         $post->subject = break_up_long_words(format_string($post->subject, true));
 676         $list .= html_writer::link($discussionurl, $post->subject, ['rel' => 'bookmark']);
 677         $list .= html_writer::end_div(); // Info.
 678         $list .= html_writer::end_tag('li');
 679     }
 680
 681     $list .= html_writer::end_tag('ul');
 682     echo $list;
 683
 684     return true;
 685 }
 686
 687 /**
 688  * Return grade for given user or all users.
 689  *
 690  * @global object
 691  * @global object
 692  * @param object $forum
 693  * @param int $userid optional user id, 0 means all users
 694  * @return array array of grades, false if none
 695  */
 696 function forum_get_user_grades($forum, $userid = 0) {
 697     global $CFG;
 698
 699     require_once($CFG->dirroot.'/rating/lib.php');
 700
 701     $ratingoptions = new stdClass;
 702     $ratingoptions->component = 'mod_forum';
 703     $ratingoptions->ratingarea = 'post';
 704
 705     //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?
 706     $ratingoptions->modulename = 'forum';
 707     $ratingoptions->moduleid   = $forum->id;
 708     $ratingoptions->userid = $userid;
 709     $ratingoptions->aggregationmethod = $forum->assessed;
 710     $ratingoptions->scaleid = $forum->scale;
 711     $ratingoptions->itemtable = 'forum_posts';
 712     $ratingoptions->itemtableusercolumn = 'userid';
 713
 714     $rm = new rating_manager();
 715     return $rm->get_user_grades($ratingoptions);
 716 }
 717
 718 /**
 719  * Update activity grades
 720  *
 721  * @category grade
 722  * @param object $forum
 723  * @param int $userid specific user only, 0 means all
 724  * @param boolean $nullifnone return null if grade does not exist
 725  * @return void
 726  */
 727 function forum_update_grades($forum, $userid=0, $nullifnone=true) {
 728     global $CFG, $DB;
 729     require_once($CFG->libdir.'/gradelib.php');
 730
 731     if (!$forum->assessed) {
 732         forum_grade_item_update($forum);
 733
 734     } else if ($grades = forum_get_user_grades($forum, $userid)) {
 735         forum_grade_item_update($forum, $grades);
 736
 737     } else if ($userid and $nullifnone) {
 738         $grade = new stdClass();
 739         $grade->userid   = $userid;
 740         $grade->rawgrade = NULL;
 741         forum_grade_item_update($forum, $grade);
 742
 743     } else {
 744         forum_grade_item_update($forum);
 745     }
 746 }
 747
 748 /**
 749  * Create/update grade item for given forum
 750  *
 751  * @category grade
 752  * @uses GRADE_TYPE_NONE
 753  * @uses GRADE_TYPE_VALUE
 754  * @uses GRADE_TYPE_SCALE
 755  * @param stdClass $forum Forum object with extra cmidnumber
 756  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
 757  * @return int 0 if ok
 758  */
 759 function forum_grade_item_update($forum, $grades=NULL) {
 760     global $CFG;
 761     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
 762         require_once($CFG->libdir.'/gradelib.php');
 763     }
 764
 765     $params = array('itemname'=>$forum->name, 'idnumber'=>$forum->cmidnumber);
 766
 767     if (!$forum->assessed or $forum->scale == 0) {
 768         $params['gradetype'] = GRADE_TYPE_NONE;
 769
 770     } else if ($forum->scale > 0) {
 771         $params['gradetype'] = GRADE_TYPE_VALUE;
 772         $params['grademax']  = $forum->scale;
 773         $params['grademin']  = 0;
 774
 775     } else if ($forum->scale < 0) {
 776         $params['gradetype'] = GRADE_TYPE_SCALE;
 777         $params['scaleid']   = -$forum->scale;
 778     }
 779
 780     if ($grades  === 'reset') {
 781         $params['reset'] = true;
 782         $grades = NULL;
 783     }
 784
 785     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, $grades, $params);
 786 }
 787
 788 /**
 789  * Delete grade item for given forum
 790  *
 791  * @category grade
 792  * @param stdClass $forum Forum object
 793  * @return grade_item
 794  */
 795 function forum_grade_item_delete($forum) {
 796     global $CFG;
 797     require_once($CFG->libdir.'/gradelib.php');
 798
 799     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, NULL, array('deleted'=>1));
 800 }
 801
 802 /**
 803  * Checks if scale is being used by any instance of forum
 804  *
 805  * This is used to find out if scale used anywhere
 806  *
 807  * @global object
 808  * @param $scaleid int
 809  * @return boolean True if the scale is used by any forum
 810  */
 811 function forum_scale_used_anywhere($scaleid) {
 812     global $DB;
 813     if ($scaleid and $DB->record_exists('forum', array('scale' => -$scaleid))) {
 814         return true;
 815     } else {
 816         return false;
 817     }
 818 }
 819
 820 // SQL FUNCTIONS ///////////////////////////////////////////////////////////
 821
 822 /**
 823  * Gets a post with all info ready for forum_print_post
 824  * Most of these joins are just to get the forum id
 825  *
 826  * @global object
 827  * @global object
 828  * @param int $postid
 829  * @return mixed array of posts or false
 830  */
 831 function forum_get_post_full($postid) {
 832     global $CFG, $DB;
 833
 834     $allnames = get_all_user_name_fields(true, 'u');
 835     return $DB->get_record_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
 836                              FROM {forum_posts} p
 837                                   JOIN {forum_discussions} d ON p.discussion = d.id
 838                                   LEFT JOIN {user} u ON p.userid = u.id
 839                             WHERE p.id = ?", array($postid));
 840 }
 841
 842 /**
 843  * Gets all posts in discussion including top parent.
 844  *
 845  * @param   int     $discussionid   The Discussion to fetch.
 846  * @param   string  $sort           The sorting to apply.
 847  * @param   bool    $tracking       Whether the user tracks this forum.
 848  * @return  array                   The posts in the discussion.
 849  */
 850 function forum_get_all_discussion_posts($discussionid, $sort, $tracking = false) {
 851     global $CFG, $DB, $USER;
 852
 853     $tr_sel  = "";
 854     $tr_join = "";
 855     $params = array();
 856
 857     if ($tracking) {
 858         $tr_sel  = ", fr.id AS postread";
 859         $tr_join = "LEFT JOIN {forum_read} fr ON (fr.postid = p.id AND fr.userid = ?)";
 860         $params[] = $USER->id;
 861     }
 862
 863     $allnames = get_all_user_name_fields(true, 'u');
 864     $params[] = $discussionid;
 865     if (!$posts = $DB->get_records_sql("SELECT p.*, $allnames, u.email, u.picture, u.imagealt $tr_sel
 866                                      FROM {forum_posts} p
 867                                           LEFT JOIN {user} u ON p.userid = u.id
 868                                           $tr_join
 869                                     WHERE p.discussion = ?
 870                                  ORDER BY $sort", $params)) {
 871         return array();
 872     }
 873
 874     foreach ($posts as $pid=>$p) {
 875         if ($tracking) {
 876             if (forum_tp_is_post_old($p)) {
 877                  $posts[$pid]->postread = true;
 878             }
 879         }
 880         if (!$p->parent) {
 881             continue;
 882         }
 883         if (!isset($posts[$p->parent])) {
 884             continue; // parent does not exist??
 885         }
 886         if (!isset($posts[$p->parent]->children)) {
 887             $posts[$p->parent]->children = array();
 888         }
 889         $posts[$p->parent]->children[$pid] =& $posts[$pid];
 890     }
 891
 892     // Start with the last child of the first post.
 893     $post = &$posts[reset($posts)->id];
 894
 895     $lastpost = false;
 896     while (!$lastpost) {
 897         if (!isset($post->children)) {
 898             $post->lastpost = true;
 899             $lastpost = true;
 900         } else {
 901              // Go to the last child of this post.
 902             $post = &$posts[end($post->children)->id];
 903         }
 904     }
 905
 906     return $posts;
 907 }
 908
 909 /**
 910  * An array of forum objects that the user is allowed to read/search through.
 911  *
 912  * @global object
 913  * @global object
 914  * @global object
 915  * @param int $userid
 916  * @param int $courseid if 0, we look for forums throughout the whole site.
 917  * @return array of forum objects, or false if no matches
 918  *         Forum objects have the following attributes:
 919  *         id, type, course, cmid, cmvisible, cmgroupmode, accessallgroups,
 920  *         viewhiddentimedposts
 921  */
 922 function forum_get_readable_forums($userid, $courseid=0) {
 923
 924     global $CFG, $DB, $USER;
 925     require_once($CFG->dirroot.'/course/lib.php');
 926
 927     if (!$forummod = $DB->get_record('modules', array('name' => 'forum'))) {
 928         print_error('notinstalled', 'forum');
 929     }
 930
 931     if ($courseid) {
 932         $courses = $DB->get_records('course', array('id' => $courseid));
 933     } else {
 934         // If no course is specified, then the user can see SITE + his courses.
 935         $courses1 = $DB->get_records('course', array('id' => SITEID));
 936         $courses2 = enrol_get_users_courses($userid, true, array('modinfo'));
 937         $courses = array_merge($courses1, $courses2);
 938     }
 939     if (!$courses) {
 940         return array();
 941     }
 942
 943     $readableforums = array();
 944
 945     foreach ($courses as $course) {
 946
 947         $modinfo = get_fast_modinfo($course);
 948
 949         if (empty($modinfo->instances['forum'])) {
 950             // hmm, no forums?
 951             continue;
 952         }
 953
 954         $courseforums = $DB->get_records('forum', array('course' => $course->id));
 955
 956         foreach ($modinfo->instances['forum'] as $forumid => $cm) {
 957             if (!$cm->uservisible or !isset($courseforums[$forumid])) {
 958                 continue;
 959             }
 960             $context = context_module::instance($cm->id);
 961             $forum = $courseforums[$forumid];
 962             $forum->context = $context;
 963             $forum->cm = $cm;
 964
 965             if (!has_capability('mod/forum:viewdiscussion', $context)) {
 966                 continue;
 967             }
 968
 969          /// group access
 970             if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
 971
 972                 $forum->onlygroups = $modinfo->get_groups($cm->groupingid);
 973                 $forum->onlygroups[] = -1;
 974             }
 975
 976         /// hidden timed discussions
 977             $forum->viewhiddentimedposts = true;
 978             if (!empty($CFG->forum_enabletimedposts)) {
 979                 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
 980                     $forum->viewhiddentimedposts = false;
 981                 }
 982             }
 983
 984         /// qanda access
 985             if ($forum->type == 'qanda'
 986                     && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
 987
 988                 // We need to check whether the user has posted in the qanda forum.
 989                 $forum->onlydiscussions = array();  // Holds discussion ids for the discussions
 990                                                     // the user is allowed to see in this forum.
 991                 if ($discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $USER->id)) {
 992                     foreach ($discussionspostedin as $d) {
 993                         $forum->onlydiscussions[] = $d->id;
 994                     }
 995                 }
 996             }
 997
 998             $readableforums[$forum->id] = $forum;
 999         }
1000
1001         unset($modinfo);
1002
1003     } // End foreach $courses
1004
1005     return $readableforums;
1006 }
1007
1008 /**
1009  * Returns a list of posts found using an array of search terms.
1010  *
1011  * @global object
1012  * @global object
1013  * @global object
1014  * @param array $searchterms array of search terms, e.g. word +word -word
1015  * @param int $courseid if 0, we search through the whole site
1016  * @param int $limitfrom
1017  * @param int $limitnum
1018  * @param int &$totalcount
1019  * @param string $extrasql
1020  * @return array|bool Array of posts found or false
1021  */
1022 function forum_search_posts($searchterms, $courseid=0, $limitfrom=0, $limitnum=50,
1023                             &$totalcount, $extrasql='') {
1024     global $CFG, $DB, $USER;
1025     require_once($CFG->libdir.'/searchlib.php');
1026
1027     $forums = forum_get_readable_forums($USER->id, $courseid);
1028
1029     if (count($forums) == 0) {
1030         $totalcount = 0;
1031         return false;
1032     }
1033
1034     $now = floor(time() / 60) * 60; // DB Cache Friendly.
1035
1036     $fullaccess = array();
1037     $where = array();
1038     $params = array();
1039
1040     foreach ($forums as $forumid => $forum) {
1041         $select = array();
1042
1043         if (!$forum->viewhiddentimedposts) {
1044             $select[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
1045             $params = array_merge($params, array('userid'.$forumid=>$USER->id, 'timestart'.$forumid=>$now, 'timeend'.$forumid=>$now));
1046         }
1047
1048         $cm = $forum->cm;
1049         $context = $forum->context;
1050
1051         if ($forum->type == 'qanda'
1052             && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
1053             if (!empty($forum->onlydiscussions)) {
1054                 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forum->onlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
1055                 $params = array_merge($params, $discussionid_params);
1056                 $select[] = "(d.id $discussionid_sql OR p.parent = 0)";
1057             } else {
1058                 $select[] = "p.parent = 0";
1059             }
1060         }
1061
1062         if (!empty($forum->onlygroups)) {
1063             list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($forum->onlygroups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
1064             $params = array_merge($params, $groupid_params);
1065             $select[] = "d.groupid $groupid_sql";
1066         }
1067
1068         if ($select) {
1069             $selects = implode(" AND ", $select);
1070             $where[] = "(d.forum = :forum{$forumid} AND $selects)";
1071             $params['forum'.$forumid] = $forumid;
1072         } else {
1073             $fullaccess[] = $forumid;
1074         }
1075     }
1076
1077     if ($fullaccess) {
1078         list($fullid_sql, $fullid_params) = $DB->get_in_or_equal($fullaccess, SQL_PARAMS_NAMED, 'fula');
1079         $params = array_merge($params, $fullid_params);
1080         $where[] = "(d.forum $fullid_sql)";
1081     }
1082
1083     $favjoin = "";
1084     if (in_array('starredonly:on', $searchterms)) {
1085         $usercontext = context_user::instance($USER->id);
1086         $ufservice = \core_favourites\service_factory::get_service_for_user_context($usercontext);
1087         list($favjoin, $favparams) = $ufservice->get_join_sql_by_type('mod_forum', 'discussions',
1088             "favourited", "d.id");
1089
1090         $searchterms = array_values(array_diff($searchterms, array('starredonly:on')));
1091         $params = array_merge($params, $favparams);
1092         $extrasql .= " AND favourited.itemid IS NOT NULL AND favourited.itemid != 0";
1093     }
1094
1095     $selectdiscussion = "(".implode(" OR ", $where).")";
1096
1097     $messagesearch = '';
1098     $searchstring = '';
1099
1100     // Need to concat these back together for parser to work.
1101     foreach($searchterms as $searchterm){
1102         if ($searchstring != '') {
1103             $searchstring .= ' ';
1104         }
1105         $searchstring .= $searchterm;
1106     }
1107
1108     // We need to allow quoted strings for the search. The quotes *should* be stripped
1109     // by the parser, but this should be examined carefully for security implications.
1110     $searchstring = str_replace("\\\"","\"",$searchstring);
1111     $parser = new search_parser();
1112     $lexer = new search_lexer($parser);
1113
1114     if ($lexer->parse($searchstring)) {
1115         $parsearray = $parser->get_parsed_array();
1116
1117         $tagjoins = '';
1118         $tagfields = [];
1119         $tagfieldcount = 0;
1120         if ($parsearray) {
1121             foreach ($parsearray as $token) {
1122                 if ($token->getType() == TOKEN_TAGS) {
1123                     for ($i = 0; $i <= substr_count($token->getValue(), ','); $i++) {
1124                         // Queries can only have a limited number of joins so set a limit sensible users won't exceed.
1125                         if ($tagfieldcount > 10) {
1126                             continue;
1127                         }
1128                         $tagjoins .= " LEFT JOIN {tag_instance} ti_$tagfieldcount
1129                                         ON p.id = ti_$tagfieldcount.itemid
1130                                             AND ti_$tagfieldcount.component = 'mod_forum'
1131                                             AND ti_$tagfieldcount.itemtype = 'forum_posts'";
1132                         $tagjoins .= " LEFT JOIN {tag} t_$tagfieldcount ON t_$tagfieldcount.id = ti_$tagfieldcount.tagid";
1133                         $tagfields[] = "t_$tagfieldcount.rawname";
1134                         $tagfieldcount++;
1135                     }
1136                 }
1137             }
1138             list($messagesearch, $msparams) = search_generate_SQL($parsearray, 'p.message', 'p.subject',
1139                 'p.userid', 'u.id', 'u.firstname',
1140                 'u.lastname', 'p.modified', 'd.forum',
1141                 $tagfields);
1142
1143             $params = ($msparams ? array_merge($params, $msparams) : $params);
1144         }
1145     }
1146
1147     $fromsql = "{forum_posts} p
1148                   INNER JOIN {forum_discussions} d ON d.id = p.discussion
1149                   INNER JOIN {user} u ON u.id = p.userid $tagjoins $favjoin";
1150
1151     $selectsql = ($messagesearch ? $messagesearch . " AND " : "").
1152                 " p.discussion = d.id
1153                AND p.userid = u.id
1154                AND $selectdiscussion
1155                    $extrasql";
1156
1157     $countsql = "SELECT COUNT(*)
1158                    FROM $fromsql
1159                   WHERE $selectsql";
1160
1161     $allnames = get_all_user_name_fields(true, 'u');
1162     $searchsql = "SELECT p.*,
1163                          d.forum,
1164                          $allnames,
1165                          u.email,
1166                          u.picture,
1167                          u.imagealt
1168                     FROM $fromsql
1169                    WHERE $selectsql
1170                 ORDER BY p.modified DESC";
1171
1172     $totalcount = $DB->count_records_sql($countsql, $params);
1173
1174     return $DB->get_records_sql($searchsql, $params, $limitfrom, $limitnum);
1175 }
1176
1177 /**
1178  * Get all the posts for a user in a forum suitable for forum_print_post
1179  *
1180  * @global object
1181  * @global object
1182  * @uses CONTEXT_MODULE
1183  * @return array
1184  */
1185 function forum_get_user_posts($forumid, $userid) {
1186     global $CFG, $DB;
1187
1188     $timedsql = "";
1189     $params = array($forumid, $userid);
1190
1191     if (!empty($CFG->forum_enabletimedposts)) {
1192         $cm = get_coursemodule_from_instance('forum', $forumid);
1193         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
1194             $now = time();
1195             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
1196             $params[] = $now;
1197             $params[] = $now;
1198         }
1199     }
1200
1201     $allnames = get_all_user_name_fields(true, 'u');
1202     return $DB->get_records_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1203                               FROM {forum} f
1204                                    JOIN {forum_discussions} d ON d.forum = f.id
1205                                    JOIN {forum_posts} p       ON p.discussion = d.id
1206                                    JOIN {user} u              ON u.id = p.userid
1207                              WHERE f.id = ?
1208                                    AND p.userid = ?
1209                                    $timedsql
1210                           ORDER BY p.modified ASC", $params);
1211 }
1212
1213 /**
1214  * Get all the discussions user participated in
1215  *
1216  * @global object
1217  * @global object
1218  * @uses CONTEXT_MODULE
1219  * @param int $forumid
1220  * @param int $userid
1221  * @return array Array or false
1222  */
1223 function forum_get_user_involved_discussions($forumid, $userid) {
1224     global $CFG, $DB;
1225
1226     $timedsql = "";
1227     $params = array($forumid, $userid);
1228     if (!empty($CFG->forum_enabletimedposts)) {
1229         $cm = get_coursemodule_from_instance('forum', $forumid);
1230         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
1231             $now = time();
1232             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
1233             $params[] = $now;
1234             $params[] = $now;
1235         }
1236     }
1237
1238     return $DB->get_records_sql("SELECT DISTINCT d.*
1239                               FROM {forum} f
1240                                    JOIN {forum_discussions} d ON d.forum = f.id
1241                                    JOIN {forum_posts} p       ON p.discussion = d.id
1242                              WHERE f.id = ?
1243                                    AND p.userid = ?
1244                                    $timedsql", $params);
1245 }
1246
1247 /**
1248  * Get all the posts for a user in a forum suitable for forum_print_post
1249  *
1250  * @global object
1251  * @global object
1252  * @param int $forumid
1253  * @param int $userid
1254  * @return array of counts or false
1255  */
1256 function forum_count_user_posts($forumid, $userid) {
1257     global $CFG, $DB;
1258
1259     $timedsql = "";
1260     $params = array($forumid, $userid);
1261     if (!empty($CFG->forum_enabletimedposts)) {
1262         $cm = get_coursemodule_from_instance('forum', $forumid);
1263         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
1264             $now = time();
1265             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
1266             $params[] = $now;
1267             $params[] = $now;
1268         }
1269     }
1270
1271     return $DB->get_record_sql("SELECT COUNT(p.id) AS postcount, MAX(p.modified) AS lastpost
1272                              FROM {forum} f
1273                                   JOIN {forum_discussions} d ON d.forum = f.id
1274                                   JOIN {forum_posts} p       ON p.discussion = d.id
1275                                   JOIN {user} u              ON u.id = p.userid
1276                             WHERE f.id = ?
1277                                   AND p.userid = ?
1278                                   $timedsql", $params);
1279 }
1280
1281 /**
1282  * Given a log entry, return the forum post details for it.
1283  *
1284  * @global object
1285  * @global object
1286  * @param object $log
1287  * @return array|null
1288  */
1289 function forum_get_post_from_log($log) {
1290     global $CFG, $DB;
1291
1292     $allnames = get_all_user_name_fields(true, 'u');
1293     if ($log->action == "add post") {
1294
1295         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
1296                                  FROM {forum_discussions} d,
1297                                       {forum_posts} p,
1298                                       {forum} f,
1299                                       {user} u
1300                                 WHERE p.id = ?
1301                                   AND d.id = p.discussion
1302                                   AND p.userid = u.id
1303                                   AND u.deleted <> '1'
1304                                   AND f.id = d.forum", array($log->info));
1305
1306
1307     } else if ($log->action == "add discussion") {
1308
1309         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
1310                                  FROM {forum_discussions} d,
1311                                       {forum_posts} p,
1312                                       {forum} f,
1313                                       {user} u
1314                                 WHERE d.id = ?
1315                                   AND d.firstpost = p.id
1316                                   AND p.userid = u.id
1317                                   AND u.deleted <> '1'
1318                                   AND f.id = d.forum", array($log->info));
1319     }
1320     return NULL;
1321 }
1322
1323 /**
1324  * Given a discussion id, return the first post from the discussion
1325  *
1326  * @global object
1327  * @global object
1328  * @param int $dicsussionid
1329  * @return array
1330  */
1331 function forum_get_firstpost_from_discussion($discussionid) {
1332     global $CFG, $DB;
1333
1334     return $DB->get_record_sql("SELECT p.*
1335                              FROM {forum_discussions} d,
1336                                   {forum_posts} p
1337                             WHERE d.id = ?
1338                               AND d.firstpost = p.id ", array($discussionid));
1339 }
1340
1341 /**
1342  * Returns an array of counts of replies to each discussion
1343  *
1344  * @param   int     $forumid
1345  * @param   string  $forumsort
1346  * @param   int     $limit
1347  * @param   int     $page
1348  * @param   int     $perpage
1349  * @param   boolean $canseeprivatereplies   Whether the current user can see private replies.
1350  * @return  array
1351  */
1352 function forum_count_discussion_replies($forumid, $forumsort = "", $limit = -1, $page = -1, $perpage = 0,
1353                                         $canseeprivatereplies = false) {
1354     global $CFG, $DB, $USER;
1355
1356     if ($limit > 0) {
1357         $limitfrom = 0;
1358         $limitnum  = $limit;
1359     } else if ($page != -1) {
1360         $limitfrom = $page*$perpage;
1361         $limitnum  = $perpage;
1362     } else {
1363         $limitfrom = 0;
1364         $limitnum  = 0;
1365     }
1366
1367     if ($forumsort == "") {
1368         $orderby = "";
1369         $groupby = "";
1370
1371     } else {
1372         $orderby = "ORDER BY $forumsort";
1373         $groupby = ", ".strtolower($forumsort);
1374         $groupby = str_replace('desc', '', $groupby);
1375         $groupby = str_replace('asc', '', $groupby);
1376     }
1377
1378     $params = ['forumid' => $forumid];
1379
1380     if (!$canseeprivatereplies) {
1381         $privatewhere = ' AND (p.privatereplyto = :currentuser1 OR p.userid = :currentuser2 OR p.privatereplyto = 0)';
1382         $params['currentuser1'] = $USER->id;
1383         $params['currentuser2'] = $USER->id;
1384     } else {
1385         $privatewhere = '';
1386     }
1387
1388     if (($limitfrom == 0 and $limitnum == 0) or $forumsort == "") {
1389         $sql = "SELECT p.discussion, COUNT(p.id) AS replies, MAX(p.id) AS lastpostid
1390                   FROM {forum_posts} p
1391                        JOIN {forum_discussions} d ON p.discussion = d.id
1392                  WHERE p.parent > 0 AND d.forum = :forumid
1393                        $privatewhere
1394               GROUP BY p.discussion";
1395         return $DB->get_records_sql($sql, $params);
1396
1397     } else {
1398         $sql = "SELECT p.discussion, (COUNT(p.id) - 1) AS replies, MAX(p.id) AS lastpostid
1399                   FROM {forum_posts} p
1400                        JOIN {forum_discussions} d ON p.discussion = d.id
1401                  WHERE d.forum = :forumid
1402                        $privatewhere
1403               GROUP BY p.discussion $groupby $orderby";
1404         return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
1405     }
1406 }
1407
1408 /**
1409  * @global object
1410  * @global object
1411  * @global object
1412  * @staticvar array $cache
1413  * @param object $forum
1414  * @param object $cm
1415  * @param object $course
1416  * @return mixed
1417  */
1418 function forum_count_discussions($forum, $cm, $course) {
1419     global $CFG, $DB, $USER;
1420
1421     static $cache = array();
1422
1423     $now = floor(time() / 60) * 60; // DB Cache Friendly.
1424
1425     $params = array($course->id);
1426
1427     if (!isset($cache[$course->id])) {
1428         if (!empty($CFG->forum_enabletimedposts)) {
1429             $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
1430             $params[] = $now;
1431             $params[] = $now;
1432         } else {
1433             $timedsql = "";
1434         }
1435
1436         $sql = "SELECT f.id, COUNT(d.id) as dcount
1437                   FROM {forum} f
1438                        JOIN {forum_discussions} d ON d.forum = f.id
1439                  WHERE f.course = ?
1440                        $timedsql
1441               GROUP BY f.id";
1442
1443         if ($counts = $DB->get_records_sql($sql, $params)) {
1444             foreach ($counts as $count) {
1445                 $counts[$count->id] = $count->dcount;
1446             }
1447             $cache[$course->id] = $counts;
1448         } else {
1449             $cache[$course->id] = array();
1450         }
1451     }
1452
1453     if (empty($cache[$course->id][$forum->id])) {
1454         return 0;
1455     }
1456
1457     $groupmode = groups_get_activity_groupmode($cm, $course);
1458
1459     if ($groupmode != SEPARATEGROUPS) {
1460         return $cache[$course->id][$forum->id];
1461     }
1462
1463     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
1464         return $cache[$course->id][$forum->id];
1465     }
1466
1467     require_once($CFG->dirroot.'/course/lib.php');
1468
1469     $modinfo = get_fast_modinfo($course);
1470
1471     $mygroups = $modinfo->get_groups($cm->groupingid);
1472
1473     // add all groups posts
1474     $mygroups[-1] = -1;
1475
1476     list($mygroups_sql, $params) = $DB->get_in_or_equal($mygroups);
1477     $params[] = $forum->id;
1478
1479     if (!empty($CFG->forum_enabletimedposts)) {
1480         $timedsql = "AND d.timestart < $now AND (d.timeend = 0 OR d.timeend > $now)";
1481         $params[] = $now;
1482         $params[] = $now;
1483     } else {
1484         $timedsql = "";
1485     }
1486
1487     $sql = "SELECT COUNT(d.id)
1488               FROM {forum_discussions} d
1489              WHERE d.groupid $mygroups_sql AND d.forum = ?
1490                    $timedsql";
1491
1492     return $DB->get_field_sql($sql, $params);
1493 }
1494
1495 /**
1496  * Get all discussions in a forum
1497  *
1498  * @global object
1499  * @global object
1500  * @global object
1501  * @uses CONTEXT_MODULE
1502  * @uses VISIBLEGROUPS
1503  * @param object $cm
1504  * @param string $forumsort
1505  * @param bool $fullpost
1506  * @param int $unused
1507  * @param int $limit
1508  * @param bool $userlastmodified
1509  * @param int $page
1510  * @param int $perpage
1511  * @param int $groupid if groups enabled, get discussions for this group overriding the current group.
1512  *                     Use FORUM_POSTS_ALL_USER_GROUPS for all the user groups
1513  * @param int $updatedsince retrieve only discussions updated since the given time
1514  * @return array
1515  */
1516 function forum_get_discussions($cm, $forumsort="", $fullpost=true, $unused=-1, $limit=-1,
1517                                 $userlastmodified=false, $page=-1, $perpage=0, $groupid = -1,
1518                                 $updatedsince = 0) {
1519     global $CFG, $DB, $USER;
1520
1521     $timelimit = '';
1522
1523     $now = floor(time() / 60) * 60;
1524     $params = array($cm->instance);
1525
1526     $modcontext = context_module::instance($cm->id);
1527
1528     if (!has_capability('mod/forum:viewdiscussion', $modcontext)) { /// User must have perms to view discussions
1529         return array();
1530     }
1531
1532     if (!empty($CFG->forum_enabletimedposts)) { /// Users must fulfill timed posts
1533
1534         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
1535             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
1536             $params[] = $now;
1537             $params[] = $now;
1538             if (isloggedin()) {
1539                 $timelimit .= " OR d.userid = ?";
1540                 $params[] = $USER->id;
1541             }
1542             $timelimit .= ")";
1543         }
1544     }
1545
1546     if ($limit > 0) {
1547         $limitfrom = 0;
1548         $limitnum  = $limit;
1549     } else if ($page != -1) {
1550         $limitfrom = $page*$perpage;
1551         $limitnum  = $perpage;
1552     } else {
1553         $limitfrom = 0;
1554         $limitnum  = 0;
1555     }
1556
1557     $groupmode    = groups_get_activity_groupmode($cm);
1558
1559     if ($groupmode) {
1560
1561         if (empty($modcontext)) {
1562             $modcontext = context_module::instance($cm->id);
1563         }
1564
1565         // Special case, we received a groupid to override currentgroup.
1566         if ($groupid > 0) {
1567             $course = get_course($cm->course);
1568             if (!groups_group_visible($groupid, $course, $cm)) {
1569                 // User doesn't belong to this group, return nothing.
1570                 return array();
1571             }
1572             $currentgroup = $groupid;
1573         } else if ($groupid === -1) {
1574             $currentgroup = groups_get_activity_group($cm);
1575         } else {
1576             // Get discussions for all groups current user can see.
1577             $currentgroup = null;
1578         }
1579
1580         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
1581             if ($currentgroup) {
1582                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
1583                 $params[] = $currentgroup;
1584             } else {
1585                 $groupselect = "";
1586             }
1587
1588         } else {
1589             // Separate groups.
1590
1591             // Get discussions for all groups current user can see.
1592             if ($currentgroup === null) {
1593                 $mygroups = array_keys(groups_get_all_groups($cm->course, $USER->id, $cm->groupingid, 'g.id'));
1594                 if (empty($mygroups)) {
1595                      $groupselect = "AND d.groupid = -1";
1596                 } else {
1597                     list($insqlgroups, $inparamsgroups) = $DB->get_in_or_equal($mygroups);
1598                     $groupselect = "AND (d.groupid = -1 OR d.groupid $insqlgroups)";
1599                     $params = array_merge($params, $inparamsgroups);
1600                 }
1601             } else if ($currentgroup) {
1602                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
1603                 $params[] = $currentgroup;
1604             } else {
1605                 $groupselect = "AND d.groupid = -1";
1606             }
1607         }
1608     } else {
1609         $groupselect = "";
1610     }
1611     if (empty($forumsort)) {
1612         $forumsort = forum_get_default_sort_order();
1613     }
1614     if (empty($fullpost)) {
1615         $postdata = "p.id, p.subject, p.modified, p.discussion, p.userid, p.created";
1616     } else {
1617         $postdata = "p.*";
1618     }
1619
1620     if (empty($userlastmodified)) {  // We don't need to know this
1621         $umfields = "";
1622         $umtable  = "";
1623     } else {
1624         $umfields = ', ' . get_all_user_name_fields(true, 'um', null, 'um') . ', um.email AS umemail, um.picture AS umpicture,
1625                         um.imagealt AS umimagealt';
1626         $umtable  = " LEFT JOIN {user} um ON (d.usermodified = um.id)";
1627     }
1628
1629     $updatedsincesql = '';
1630     if (!empty($updatedsince)) {
1631         $updatedsincesql = 'AND d.timemodified > ?';
1632         $params[] = $updatedsince;
1633     }
1634
1635     $discussionfields = "d.id as discussionid, d.course, d.forum, d.name, d.firstpost, d.groupid, d.assessed," .
1636     " d.timemodified, d.usermodified, d.timestart, d.timeend, d.pinned, d.timelocked";
1637
1638     $allnames = get_all_user_name_fields(true, 'u');
1639     $sql = "SELECT $postdata, $discussionfields,
1640                    $allnames, u.email, u.picture, u.imagealt $umfields
1641               FROM {forum_discussions} d
1642                    JOIN {forum_posts} p ON p.discussion = d.id
1643                    JOIN {user} u ON p.userid = u.id
1644                    $umtable
1645              WHERE d.forum = ? AND p.parent = 0
1646                    $timelimit $groupselect $updatedsincesql
1647           ORDER BY $forumsort, d.id DESC";
1648
1649     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
1650 }
1651
1652 /**
1653  * Gets the neighbours (previous and next) of a discussion.
1654  *
1655  * The calculation is based on the timemodified when time modified or time created is identical
1656  * It will revert to using the ID to sort consistently. This is better tha skipping a discussion.
1657  *
1658  * For blog-style forums, the calculation is based on the original creation time of the
1659  * blog post.
1660  *
1661  * Please note that this does not check whether or not the discussion passed is accessible
1662  * by the user, it simply uses it as a reference to find the neighbours. On the other hand,
1663  * the returned neighbours are checked and are accessible to the current user.
1664  *
1665  * @param object $cm The CM record.
1666  * @param object $discussion The discussion record.
1667  * @param object $forum The forum instance record.
1668  * @return array That always contains the keys 'prev' and 'next'. When there is a result
1669  *               they contain the record with minimal information such as 'id' and 'name'.
1670  *               When the neighbour is not found the value is false.
1671  */
1672 function forum_get_discussion_neighbours($cm, $discussion, $forum) {
1673     global $CFG, $DB, $USER;
1674
1675     if ($cm->instance != $discussion->forum or $discussion->forum != $forum->id or $forum->id != $cm->instance) {
1676         throw new coding_exception('Discussion is not part of the same forum.');
1677     }
1678
1679     $neighbours = array('prev' => false, 'next' => false);
1680     $now = floor(time() / 60) * 60;
1681     $params = array();
1682
1683     $modcontext = context_module::instance($cm->id);
1684     $groupmode    = groups_get_activity_groupmode($cm);
1685     $currentgroup = groups_get_activity_group($cm);
1686
1687     // Users must fulfill timed posts.
1688     $timelimit = '';
1689     if (!empty($CFG->forum_enabletimedposts)) {
1690         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
1691             $timelimit = ' AND ((d.timestart <= :tltimestart AND (d.timeend = 0 OR d.timeend > :tltimeend))';
1692             $params['tltimestart'] = $now;
1693             $params['tltimeend'] = $now;
1694             if (isloggedin()) {
1695                 $timelimit .= ' OR d.userid = :tluserid';
1696                 $params['tluserid'] = $USER->id;
1697             }
1698             $timelimit .= ')';
1699         }
1700     }
1701
1702     // Limiting to posts accessible according to groups.
1703     $groupselect = '';
1704     if ($groupmode) {
1705         if ($groupmode == VISIBLEGROUPS || has_capability('moodle/site:accessallgroups', $modcontext)) {
1706             if ($currentgroup) {
1707                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
1708                 $params['groupid'] = $currentgroup;
1709             }
1710         } else {
1711             if ($currentgroup) {
1712                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
1713                 $params['groupid'] = $currentgroup;
1714             } else {
1715                 $groupselect = 'AND d.groupid = -1';
1716             }
1717         }
1718     }
1719
1720     $params['forumid'] = $cm->instance;
1721     $params['discid1'] = $discussion->id;
1722     $params['discid2'] = $discussion->id;
1723     $params['discid3'] = $discussion->id;
1724     $params['discid4'] = $discussion->id;
1725     $params['disctimecompare1'] = $discussion->timemodified;
1726     $params['disctimecompare2'] = $discussion->timemodified;
1727     $params['pinnedstate1'] = (int) $discussion->pinned;
1728     $params['pinnedstate2'] = (int) $discussion->pinned;
1729     $params['pinnedstate3'] = (int) $discussion->pinned;
1730     $params['pinnedstate4'] = (int) $discussion->pinned;
1731
1732     $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
1733               FROM {forum_discussions} d
1734               JOIN {forum_posts} p ON d.firstpost = p.id
1735              WHERE d.forum = :forumid
1736                AND d.id <> :discid1
1737                    $timelimit
1738                    $groupselect";
1739     $comparefield = "d.timemodified";
1740     $comparevalue = ":disctimecompare1";
1741     $comparevalue2  = ":disctimecompare2";
1742     if (!empty($CFG->forum_enabletimedposts)) {
1743         // Here we need to take into account the release time (timestart)
1744         // if one is set, of the neighbouring posts and compare it to the
1745         // timestart or timemodified of *this* post depending on if the
1746         // release date of this post is in the future or not.
1747         // This stops discussions that appear later because of the
1748         // timestart value from being buried under discussions that were
1749         // made afterwards.
1750         $comparefield = "CASE WHEN d.timemodified < d.timestart
1751                                 THEN d.timestart ELSE d.timemodified END";
1752         if ($discussion->timemodified < $discussion->timestart) {
1753             // Normally we would just use the timemodified for sorting
1754             // discussion posts. However, when timed discussions are enabled,
1755             // then posts need to be sorted base on the later of timemodified
1756             // or the release date of the post (timestart).
1757             $params['disctimecompare1'] = $discussion->timestart;
1758             $params['disctimecompare2'] = $discussion->timestart;
1759         }
1760     }
1761     $orderbydesc = forum_get_default_sort_order(true, $comparefield, 'd', false);
1762     $orderbyasc = forum_get_default_sort_order(false, $comparefield, 'd', false);
1763
1764     if ($forum->type === 'blog') {
1765          $subselect = "SELECT pp.created
1766                    FROM {forum_discussions} dd
1767                    JOIN {forum_posts} pp ON dd.firstpost = pp.id ";
1768
1769          $subselectwhere1 = " WHERE dd.id = :discid3";
1770          $subselectwhere2 = " WHERE dd.id = :discid4";
1771
1772          $comparefield = "p.created";
1773
1774          $sub1 = $subselect.$subselectwhere1;
1775          $comparevalue = "($sub1)";
1776
1777          $sub2 = $subselect.$subselectwhere2;
1778          $comparevalue2 = "($sub2)";
1779
1780          $orderbydesc = "d.pinned, p.created DESC";
1781          $orderbyasc = "d.pinned, p.created ASC";
1782     }
1783
1784     $prevsql = $sql . " AND ( (($comparefield < $comparevalue) AND :pinnedstate1 = d.pinned)
1785                          OR ($comparefield = $comparevalue2 AND (d.pinned = 0 OR d.pinned = :pinnedstate4) AND d.id < :discid2)
1786                          OR (d.pinned = 0 AND d.pinned <> :pinnedstate2))
1787                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbydesc, d.id DESC";
1788
1789     $nextsql = $sql . " AND ( (($comparefield > $comparevalue) AND :pinnedstate1 = d.pinned)
1790                          OR ($comparefield = $comparevalue2 AND (d.pinned = 1 OR d.pinned = :pinnedstate4) AND d.id > :discid2)
1791                          OR (d.pinned = 1 AND d.pinned <> :pinnedstate2))
1792                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbyasc, d.id ASC";
1793
1794     $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
1795     $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
1796     return $neighbours;
1797 }
1798
1799 /**
1800  * Get the sql to use in the ORDER BY clause for forum discussions.
1801  *
1802  * This has the ordering take timed discussion windows into account.
1803  *
1804  * @param bool $desc True for DESC, False for ASC.
1805  * @param string $compare The field in the SQL to compare to normally sort by.
1806  * @param string $prefix The prefix being used for the discussion table.
1807  * @param bool $pinned sort pinned posts to the top
1808  * @return string
1809  */
1810 function forum_get_default_sort_order($desc = true, $compare = 'd.timemodified', $prefix = 'd', $pinned = true) {
1811     global $CFG;
1812
1813     if (!empty($prefix)) {
1814         $prefix .= '.';
1815     }
1816
1817     $dir = $desc ? 'DESC' : 'ASC';
1818
1819     if ($pinned == true) {
1820         $pinned = "{$prefix}pinned DESC,";
1821     } else {
1822         $pinned = '';
1823     }
1824
1825     $sort = "{$prefix}timemodified";
1826     if (!empty($CFG->forum_enabletimedposts)) {
1827         $sort = "CASE WHEN {$compare} < {$prefix}timestart
1828                  THEN {$prefix}timestart
1829                  ELSE {$compare}
1830                  END";
1831     }
1832     return "$pinned $sort $dir";
1833 }
1834
1835 /**
1836  *
1837  * @global object
1838  * @global object
1839  * @global object
1840  * @uses CONTEXT_MODULE
1841  * @uses VISIBLEGROUPS
1842  * @param object $cm
1843  * @return array
1844  */
1845 function forum_get_discussions_unread($cm) {
1846     global $CFG, $DB, $USER;
1847
1848     $now = floor(time() / 60) * 60;
1849     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
1850
1851     $params = array();
1852     $groupmode    = groups_get_activity_groupmode($cm);
1853     $currentgroup = groups_get_activity_group($cm);
1854
1855     if ($groupmode) {
1856         $modcontext = context_module::instance($cm->id);
1857
1858         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
1859             if ($currentgroup) {
1860                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
1861                 $params['currentgroup'] = $currentgroup;
1862             } else {
1863                 $groupselect = "";
1864             }
1865
1866         } else {
1867             //separate groups without access all
1868             if ($currentgroup) {
1869                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
1870                 $params['currentgroup'] = $currentgroup;
1871             } else {
1872                 $groupselect = "AND d.groupid = -1";
1873             }
1874         }
1875     } else {
1876         $groupselect = "";
1877     }
1878
1879     if (!empty($CFG->forum_enabletimedposts)) {
1880         $timedsql = "AND d.timestart < :now1 AND (d.timeend = 0 OR d.timeend > :now2)";
1881         $params['now1'] = $now;
1882         $params['now2'] = $now;
1883     } else {
1884         $timedsql = "";
1885     }
1886
1887     $sql = "SELECT d.id, COUNT(p.id) AS unread
1888               FROM {forum_discussions} d
1889                    JOIN {forum_posts} p     ON p.discussion = d.id
1890                    LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = $USER->id)
1891              WHERE d.forum = {$cm->instance}
1892                    AND p.modified >= :cutoffdate AND r.id is NULL
1893                    $groupselect
1894                    $timedsql
1895           GROUP BY d.id";
1896     $params['cutoffdate'] = $cutoffdate;
1897
1898     if ($unreads = $DB->get_records_sql($sql, $params)) {
1899         foreach ($unreads as $unread) {
1900             $unreads[$unread->id] = $unread->unread;
1901         }
1902         return $unreads;
1903     } else {
1904         return array();
1905     }
1906 }
1907
1908 /**
1909  * @global object
1910  * @global object
1911  * @global object
1912  * @uses CONEXT_MODULE
1913  * @uses VISIBLEGROUPS
1914  * @param object $cm
1915  * @return array
1916  */
1917 function forum_get_discussions_count($cm) {
1918     global $CFG, $DB, $USER;
1919
1920     $now = floor(time() / 60) * 60;
1921     $params = array($cm->instance);
1922     $groupmode    = groups_get_activity_groupmode($cm);
1923     $currentgroup = groups_get_activity_group($cm);
1924
1925     if ($groupmode) {
1926         $modcontext = context_module::instance($cm->id);
1927
1928         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
1929             if ($currentgroup) {
1930                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
1931                 $params[] = $currentgroup;
1932             } else {
1933                 $groupselect = "";
1934             }
1935
1936         } else {
1937             //seprate groups without access all
1938             if ($currentgroup) {
1939                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
1940                 $params[] = $currentgroup;
1941             } else {
1942                 $groupselect = "AND d.groupid = -1";
1943             }
1944         }
1945     } else {
1946         $groupselect = "";
1947     }
1948
1949     $timelimit = "";
1950
1951     if (!empty($CFG->forum_enabletimedposts)) {
1952
1953         $modcontext = context_module::instance($cm->id);
1954
1955         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
1956             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
1957             $params[] = $now;
1958             $params[] = $now;
1959             if (isloggedin()) {
1960                 $timelimit .= " OR d.userid = ?";
1961                 $params[] = $USER->id;
1962             }
1963             $timelimit .= ")";
1964         }
1965     }
1966
1967     $sql = "SELECT COUNT(d.id)
1968               FROM {forum_discussions} d
1969                    JOIN {forum_posts} p ON p.discussion = d.id
1970              WHERE d.forum = ? AND p.parent = 0
1971                    $groupselect $timelimit";
1972
1973     return $DB->get_field_sql($sql, $params);
1974 }
1975
1976
1977 // OTHER FUNCTIONS ///////////////////////////////////////////////////////////
1978
1979
1980 /**
1981  * @global object
1982  * @global object
1983  * @param int $courseid
1984  * @param string $type
1985  */
1986 function forum_get_course_forum($courseid, $type) {
1987 // How to set up special 1-per-course forums
1988     global $CFG, $DB, $OUTPUT, $USER;
1989
1990     if ($forums = $DB->get_records_select("forum", "course = ? AND type = ?", array($courseid, $type), "id ASC")) {
1991         // There should always only be ONE, but with the right combination of
1992         // errors there might be more.  In this case, just return the oldest one (lowest ID).
1993         foreach ($forums as $forum) {
1994             return $forum;   // ie the first one
1995         }
1996     }
1997
1998     // Doesn't exist, so create one now.
1999     $forum = new stdClass();
2000     $forum->course = $courseid;
2001     $forum->type = "$type";
2002     if (!empty($USER->htmleditor)) {
2003         $forum->introformat = $USER->htmleditor;
2004     }
2005     switch ($forum->type) {
2006         case "news":
2007             $forum->name  = get_string("namenews", "forum");
2008             $forum->intro = get_string("intronews", "forum");
2009             $forum->introformat = FORMAT_HTML;
2010             $forum->forcesubscribe = FORUM_FORCESUBSCRIBE;
2011             $forum->assessed = 0;
2012             if ($courseid == SITEID) {
2013                 $forum->name  = get_string("sitenews");
2014                 $forum->forcesubscribe = 0;
2015             }
2016             break;
2017         case "social":
2018             $forum->name  = get_string("namesocial", "forum");
2019             $forum->intro = get_string("introsocial", "forum");
2020             $forum->introformat = FORMAT_HTML;
2021             $forum->assessed = 0;
2022             $forum->forcesubscribe = 0;
2023             break;
2024         case "blog":
2025             $forum->name = get_string('blogforum', 'forum');
2026             $forum->intro = get_string('introblog', 'forum');
2027             $forum->introformat = FORMAT_HTML;
2028             $forum->assessed = 0;
2029             $forum->forcesubscribe = 0;
2030             break;
2031         default:
2032             echo $OUTPUT->notification("That forum type doesn't exist!");
2033             return false;
2034             break;
2035     }
2036
2037     $forum->timemodified = time();
2038     $forum->id = $DB->insert_record("forum", $forum);
2039
2040     if (! $module = $DB->get_record("modules", array("name" => "forum"))) {
2041         echo $OUTPUT->notification("Could not find forum module!!");
2042         return false;
2043     }
2044     $mod = new stdClass();
2045     $mod->course = $courseid;
2046     $mod->module = $module->id;
2047     $mod->instance = $forum->id;
2048     $mod->section = 0;
2049     include_once("$CFG->dirroot/course/lib.php");
2050     if (! $mod->coursemodule = add_course_module($mod) ) {
2051         echo $OUTPUT->notification("Could not add a new course module to the course '" . $courseid . "'");
2052         return false;
2053     }
2054     $sectionid = course_add_cm_to_section($courseid, $mod->coursemodule, 0);
2055     return $DB->get_record("forum", array("id" => "$forum->id"));
2056 }
2057
2058 /**
2059  * Return rating related permissions
2060  *
2061  * @param string $options the context id
2062  * @return array an associative array of the user's rating permissions
2063  */
2064 function forum_rating_permissions($contextid, $component, $ratingarea) {
2065     $context = context::instance_by_id($contextid, MUST_EXIST);
2066     if ($component != 'mod_forum' || $ratingarea != 'post') {
2067         // We don't know about this component/ratingarea so just return null to get the
2068         // default restrictive permissions.
2069         return null;
2070     }
2071     return array(
2072         'view'    => has_capability('mod/forum:viewrating', $context),
2073         'viewany' => has_capability('mod/forum:viewanyrating', $context),
2074         'viewall' => has_capability('mod/forum:viewallratings', $context),
2075         'rate'    => has_capability('mod/forum:rate', $context)
2076     );
2077 }
2078
2079 /**
2080  * Validates a submitted rating
2081  * @param array $params submitted data
2082  *            context => object the context in which the rated items exists [required]
2083  *            component => The component for this module - should always be mod_forum [required]
2084  *            ratingarea => object the context in which the rated items exists [required]
2085  *
2086  *            itemid => int the ID of the object being rated [required]
2087  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
2088  *            rating => int the submitted rating [required]
2089  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
2090  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
2091  * @return boolean true if the rating is valid. Will throw rating_exception if not
2092  */
2093 function forum_rating_validate($params) {
2094     global $DB, $USER;
2095
2096     // Check the component is mod_forum
2097     if ($params['component'] != 'mod_forum') {
2098         throw new rating_exception('invalidcomponent');
2099     }
2100
2101     // Check the ratingarea is post (the only rating area in forum)
2102     if ($params['ratingarea'] != 'post') {
2103         throw new rating_exception('invalidratingarea');
2104     }
2105
2106     // Check the rateduserid is not the current user .. you can't rate your own posts
2107     if ($params['rateduserid'] == $USER->id) {
2108         throw new rating_exception('nopermissiontorate');
2109     }
2110
2111     // Fetch all the related records ... we need to do this anyway to call forum_user_can_see_post
2112     $post = $DB->get_record('forum_posts', array('id' => $params['itemid'], 'userid' => $params['rateduserid']), '*', MUST_EXIST);
2113     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion), '*', MUST_EXIST);
2114     $forum = $DB->get_record('forum', array('id' => $discussion->forum), '*', MUST_EXIST);
2115     $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
2116     $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id , false, MUST_EXIST);
2117     $context = context_module::instance($cm->id);
2118
2119     // Make sure the context provided is the context of the forum
2120     if ($context->id != $params['context']->id) {
2121         throw new rating_exception('invalidcontext');
2122     }
2123
2124     if ($forum->scale != $params['scaleid']) {
2125         //the scale being submitted doesnt match the one in the database
2126         throw new rating_exception('invalidscaleid');
2127     }
2128
2129     // check the item we're rating was created in the assessable time window
2130     if (!empty($forum->assesstimestart) && !empty($forum->assesstimefinish)) {
2131         if ($post->created < $forum->assesstimestart || $post->created > $forum->assesstimefinish) {
2132             throw new rating_exception('notavailable');
2133         }
2134     }
2135
2136     //check that the submitted rating is valid for the scale
2137
2138     // lower limit
2139     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
2140         throw new rating_exception('invalidnum');
2141     }
2142
2143     // upper limit
2144     if ($forum->scale < 0) {
2145         //its a custom scale
2146         $scalerecord = $DB->get_record('scale', array('id' => -$forum->scale));
2147         if ($scalerecord) {
2148             $scalearray = explode(',', $scalerecord->scale);
2149             if ($params['rating'] > count($scalearray)) {
2150                 throw new rating_exception('invalidnum');
2151             }
2152         } else {
2153             throw new rating_exception('invalidscaleid');
2154         }
2155     } else if ($params['rating'] > $forum->scale) {
2156         //if its numeric and submitted rating is above maximum
2157         throw new rating_exception('invalidnum');
2158     }
2159
2160     // Make sure groups allow this user to see the item they're rating
2161     if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
2162         if (!groups_group_exists($discussion->groupid)) { // Can't find group
2163             throw new rating_exception('cannotfindgroup');//something is wrong
2164         }
2165
2166         if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
2167             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
2168             throw new rating_exception('notmemberofgroup');
2169         }
2170     }
2171
2172     // perform some final capability checks
2173     if (!forum_user_can_see_post($forum, $discussion, $post, $USER, $cm)) {
2174         throw new rating_exception('nopermissiontorate');
2175     }
2176
2177     return true;
2178 }
2179
2180 /**
2181  * Can the current user see ratings for a given itemid?
2182  *
2183  * @param array $params submitted data
2184  *            contextid => int contextid [required]
2185  *            component => The component for this module - should always be mod_forum [required]
2186  *            ratingarea => object the context in which the rated items exists [required]
2187  *            itemid => int the ID of the object being rated [required]
2188  *            scaleid => int scale id [optional]
2189  * @return bool
2190  * @throws coding_exception
2191  * @throws rating_exception
2192  */
2193 function mod_forum_rating_can_see_item_ratings($params) {
2194     global $DB, $USER;
2195
2196     // Check the component is mod_forum.
2197     if (!isset($params['component']) || $params['component'] != 'mod_forum') {
2198         throw new rating_exception('invalidcomponent');
2199     }
2200
2201     // Check the ratingarea is post (the only rating area in forum).
2202     if (!isset($params['ratingarea']) || $params['ratingarea'] != 'post') {
2203         throw new rating_exception('invalidratingarea');
2204     }
2205
2206     if (!isset($params['itemid'])) {
2207         throw new rating_exception('invaliditemid');
2208     }
2209
2210     $post = $DB->get_record('forum_posts', array('id' => $params['itemid']), '*', MUST_EXIST);
2211     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion), '*', MUST_EXIST);
2212     $forum = $DB->get_record('forum', array('id' => $discussion->forum), '*', MUST_EXIST);
2213     $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
2214     $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id , false, MUST_EXIST);
2215
2216     // Perform some final capability checks.
2217     if (!forum_user_can_see_post($forum, $discussion, $post, $USER, $cm)) {
2218         return false;
2219     }
2220
2221     return true;
2222 }
2223
2224 /**
2225  * This function prints the overview of a discussion in the forum listing.
2226  * It needs some discussion information and some post information, these
2227  * happen to be combined for efficiency in the $post parameter by the function
2228  * that calls this one: forum_print_latest_discussions()
2229  *
2230  * @global object
2231  * @global object
2232  * @param object $post The post object (passed by reference for speed).
2233  * @param object $forum The forum object.
2234  * @param int $group Current group.
2235  * @param string $datestring Format to use for the dates.
2236  * @param boolean $cantrack Is tracking enabled for this forum.
2237  * @param boolean $forumtracked Is the user tracking this forum.
2238  * @param boolean $canviewparticipants True if user has the viewparticipants permission for this course
2239  * @param boolean $canviewhiddentimedposts True if user has the viewhiddentimedposts permission for this forum
2240  */
2241 function forum_print_discussion_header(&$post, $forum, $group = -1, $datestring = "",
2242                                         $cantrack = true, $forumtracked = true, $canviewparticipants = true, $modcontext = null,
2243                                         $canviewhiddentimedposts = false) {
2244
2245     global $COURSE, $USER, $CFG, $OUTPUT, $PAGE;
2246
2247     static $rowcount;
2248     static $strmarkalldread;
2249
2250     if (empty($modcontext)) {
2251         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
2252             print_error('invalidcoursemodule');
2253         }
2254         $modcontext = context_module::instance($cm->id);
2255     }
2256
2257     if (!isset($rowcount)) {
2258         $rowcount = 0;
2259         $strmarkalldread = get_string('markalldread', 'forum');
2260     } else {
2261         $rowcount = ($rowcount + 1) % 2;
2262     }
2263
2264     $post->subject = format_string($post->subject,true);
2265
2266     $canviewfullnames = has_capability('moodle/site:viewfullnames', $modcontext);
2267     $timeddiscussion = !empty($CFG->forum_enabletimedposts) && ($post->timestart || $post->timeend);
2268     $timedoutsidewindow = '';
2269     if ($timeddiscussion && ($post->timestart > time() || ($post->timeend != 0 && $post->timeend < time()))) {
2270         $timedoutsidewindow = ' dimmed_text';
2271     }
2272
2273     echo "\n\n";
2274     echo '<tr class="discussion r'.$rowcount.$timedoutsidewindow.'">';
2275
2276     $topicclass = 'topic starter';
2277     if (FORUM_DISCUSSION_PINNED == $post->pinned) {
2278         $topicclass .= ' pinned';
2279     }
2280     echo '<td class="'.$topicclass.'">';
2281     if (FORUM_DISCUSSION_PINNED == $post->pinned) {
2282         echo $OUTPUT->pix_icon('i/pinned', get_string('discussionpinned', 'forum'), 'mod_forum');
2283     }
2284     $canalwaysseetimedpost = $USER->id == $post->userid || $canviewhiddentimedposts;
2285     if ($timeddiscussion && $canalwaysseetimedpost) {
2286         echo $PAGE->get_renderer('mod_forum')->timed_discussion_tooltip($post, empty($timedoutsidewindow));
2287     }
2288
2289     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">'.$post->subject.'</a>';
2290     echo "</td>\n";
2291
2292     // Picture
2293     $postuser = new stdClass();
2294     $postuserfields = explode(',', user_picture::fields());
2295     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
2296     $postuser->id = $post->userid;
2297     echo '<td class="author">';
2298     echo '<div class="media">';
2299     echo '<span class="float-left">';
2300     echo $OUTPUT->user_picture($postuser, array('courseid'=>$forum->course));
2301     echo '</span>';
2302     // User name
2303     echo '<div class="media-body">';
2304     $fullname = fullname($postuser, $canviewfullnames);
2305     echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->userid.'&amp;course='.$forum->course.'">'.$fullname.'</a>';
2306     echo '</div>';
2307     echo '</div>';
2308     echo "</td>\n";
2309
2310     // Group picture
2311     if ($group !== -1) {  // Groups are active - group is a group data object or NULL
2312         echo '<td class="picture group">';
2313         if (!empty($group->picture) and empty($group->hidepicture)) {
2314             if ($canviewparticipants && $COURSE->groupmode) {
2315                 $picturelink = true;
2316             } else {
2317                 $picturelink = false;
2318             }
2319             print_group_picture($group, $forum->course, false, false, $picturelink);
2320         } else if (isset($group->id)) {
2321             if ($canviewparticipants && $COURSE->groupmode) {
2322                 echo '<a href="'.$CFG->wwwroot.'/user/index.php?id='.$forum->course.'&amp;group='.$group->id.'">'.$group->name.'</a>';
2323             } else {
2324                 echo $group->name;
2325             }
2326         }
2327         echo "</td>\n";
2328     }
2329
2330     if (has_capability('mod/forum:viewdiscussion', $modcontext)) {   // Show the column with replies
2331         echo '<td class="replies">';
2332         echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
2333         echo $post->replies.'</a>';
2334         echo "</td>\n";
2335
2336         if ($cantrack) {
2337             echo '<td class="replies">';
2338             if ($forumtracked) {
2339                 if ($post->unread > 0) {
2340                     echo '<span class="unread">';
2341                     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'#unread">';
2342                     echo $post->unread;
2343                     echo '</a>';
2344                     echo '<a title="'.$strmarkalldread.'" href="'.$CFG->wwwroot.'/mod/forum/markposts.php?f='.
2345                          $forum->id.'&amp;d='.$post->discussion.'&amp;mark=read&amp;return=/mod/forum/view.php&amp;sesskey=' .
2346                          sesskey() . '">' . $OUTPUT->pix_icon('t/markasread', $strmarkalldread) . '</a>';
2347                     echo '</span>';
2348                 } else {
2349                     echo '<span class="read">';
2350                     echo $post->unread;
2351                     echo '</span>';
2352                 }
2353             } else {
2354                 echo '<span class="read">';
2355                 echo '-';
2356                 echo '</span>';
2357             }
2358             echo "</td>\n";
2359         }
2360     }
2361
2362     echo '<td class="lastpost">';
2363     $usedate = (empty($post->timemodified)) ? $post->created : $post->timemodified;
2364     $parenturl = '';
2365     $usermodified = new stdClass();
2366     $usermodified->id = $post->usermodified;
2367     $usermodified = username_load_fields_from_object($usermodified, $post, 'um');
2368
2369     // In QA forums we check that the user can view participants.
2370     if ($forum->type !== 'qanda' || $canviewparticipants) {
2371         echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->usermodified.'&amp;course='.$forum->course.'">'.
2372              fullname($usermodified, $canviewfullnames).'</a><br />';
2373         $parenturl = (empty($post->lastpostid)) ? '' : '&amp;parent='.$post->lastpostid;
2374     }
2375
2376     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.$parenturl.'">'.
2377           userdate_htmltime($usedate, $datestring).'</a>';
2378     echo "</td>\n";
2379
2380     // is_guest should be used here as this also checks whether the user is a guest in the current course.
2381     // Guests and visitors cannot subscribe - only enrolled users.
2382     if ((!is_guest($modcontext, $USER) && isloggedin()) && has_capability('mod/forum:viewdiscussion', $modcontext)) {
2383         // Discussion subscription.
2384         if (\mod_forum\subscriptions::is_subscribable($forum)) {
2385             echo '<td class="discussionsubscription">';
2386             echo forum_get_discussion_subscription_icon($forum, $post->discussion);
2387             echo '</td>';
2388         }
2389     }
2390
2391     echo "</tr>\n\n";
2392
2393 }
2394
2395 /**
2396  * Return the markup for the discussion subscription toggling icon.
2397  *
2398  * @param stdClass $forum The forum object.
2399  * @param int $discussionid The discussion to create an icon for.
2400  * @return string The generated markup.
2401  */
2402 function forum_get_discussion_subscription_icon($forum, $discussionid, $returnurl = null, $includetext = false) {
2403     global $USER, $OUTPUT, $PAGE;
2404
2405     if ($returnurl === null && $PAGE->url) {
2406         $returnurl = $PAGE->url->out();
2407     }
2408
2409     $o = '';
2410     $subscriptionstatus = \mod_forum\subscriptions::is_subscribed($USER->id, $forum, $discussionid);
2411     $subscriptionlink = new moodle_url('/mod/forum/subscribe.php', array(
2412         'sesskey' => sesskey(),
2413         'id' => $forum->id,
2414         'd' => $discussionid,
2415         'returnurl' => $returnurl,
2416     ));
2417
2418     if ($includetext) {
2419         $o .= $subscriptionstatus ? get_string('subscribed', 'mod_forum') : get_string('notsubscribed', 'mod_forum');
2420     }
2421
2422     if ($subscriptionstatus) {
2423         $output = $OUTPUT->pix_icon('t/subscribed', get_string('clicktounsubscribe', 'forum'), 'mod_forum');
2424         if ($includetext) {
2425             $output .= get_string('subscribed', 'mod_forum');
2426         }
2427
2428         return html_writer::link($subscriptionlink, $output, array(
2429                 'title' => get_string('clicktounsubscribe', 'forum'),
2430                 'class' => 'discussiontoggle btn btn-link',
2431                 'data-forumid' => $forum->id,
2432                 'data-discussionid' => $discussionid,
2433                 'data-includetext' => $includetext,
2434             ));
2435
2436     } else {
2437         $output = $OUTPUT->pix_icon('t/unsubscribed', get_string('clicktosubscribe', 'forum'), 'mod_forum');
2438         if ($includetext) {
2439             $output .= get_string('notsubscribed', 'mod_forum');
2440         }
2441
2442         return html_writer::link($subscriptionlink, $output, array(
2443                 'title' => get_string('clicktosubscribe', 'forum'),
2444                 'class' => 'discussiontoggle btn btn-link',
2445                 'data-forumid' => $forum->id,
2446                 'data-discussionid' => $discussionid,
2447                 'data-includetext' => $includetext,
2448             ));
2449     }
2450 }
2451
2452 /**
2453  * Return a pair of spans containing classes to allow the subscribe and
2454  * unsubscribe icons to be pre-loaded by a browser.
2455  *
2456  * @return string The generated markup
2457  */
2458 function forum_get_discussion_subscription_icon_preloaders() {
2459     $o = '';
2460     $o .= html_writer::span('&nbsp;', 'preload-subscribe');
2461     $o .= html_writer::span('&nbsp;', 'preload-unsubscribe');
2462     return $o;
2463 }
2464
2465 /**
2466  * Print the drop down that allows the user to select how they want to have
2467  * the discussion displayed.
2468  *
2469  * @param int $id forum id if $forumtype is 'single',
2470  *              discussion id for any other forum type
2471  * @param mixed $mode forum layout mode
2472  * @param string $forumtype optional
2473  */
2474 function forum_print_mode_form($id, $mode, $forumtype='') {
2475     global $OUTPUT;
2476     if ($forumtype == 'single') {
2477         $select = new single_select(new moodle_url("/mod/forum/view.php", array('f'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
2478         $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
2479         $select->class = "forummode";
2480     } else {
2481         $select = new single_select(new moodle_url("/mod/forum/discuss.php", array('d'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
2482         $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
2483     }
2484     echo $OUTPUT->render($select);
2485 }
2486
2487 /**
2488  * @global object
2489  * @param object $course
2490  * @param string $search
2491  * @return string
2492  */
2493 function forum_search_form($course, $search='') {
2494     global $CFG, $PAGE;
2495     $forumsearch = new \mod_forum\output\quick_search_form($course->id, $search);
2496     $output = $PAGE->get_renderer('mod_forum');
2497     return $output->render($forumsearch);
2498 }
2499
2500
2501 /**
2502  * @global object
2503  * @global object
2504  */
2505 function forum_set_return() {
2506     global $CFG, $SESSION;
2507
2508     if (! isset($SESSION->fromdiscussion)) {
2509         $referer = get_local_referer(false);
2510         // If the referer is NOT a login screen then save it.
2511         if (! strncasecmp("$CFG->wwwroot/login", $referer, 300)) {
2512             $SESSION->fromdiscussion = $referer;
2513         }
2514     }
2515 }
2516
2517
2518 /**
2519  * @global object
2520  * @param string|\moodle_url $default
2521  * @return string
2522  */
2523 function forum_go_back_to($default) {
2524     global $SESSION;
2525
2526     if (!empty($SESSION->fromdiscussion)) {
2527         $returnto = $SESSION->fromdiscussion;
2528         unset($SESSION->fromdiscussion);
2529         return $returnto;
2530     } else {
2531         return $default;
2532     }
2533 }
2534
2535 /**
2536  * Given a discussion object that is being moved to $forumto,
2537  * this function checks all posts in that discussion
2538  * for attachments, and if any are found, these are
2539  * moved to the new forum directory.
2540  *
2541  * @global object
2542  * @param object $discussion
2543  * @param int $forumfrom source forum id
2544  * @param int $forumto target forum id
2545  * @return bool success
2546  */
2547 function forum_move_attachments($discussion, $forumfrom, $forumto) {
2548     global $DB;
2549
2550     $fs = get_file_storage();
2551
2552     $newcm = get_coursemodule_from_instance('forum', $forumto);
2553     $oldcm = get_coursemodule_from_instance('forum', $forumfrom);
2554
2555     $newcontext = context_module::instance($newcm->id);
2556     $oldcontext = context_module::instance($oldcm->id);
2557
2558     // loop through all posts, better not use attachment flag ;-)
2559     if ($posts = $DB->get_records('forum_posts', array('discussion'=>$discussion->id), '', 'id, attachment')) {
2560         foreach ($posts as $post) {
2561             $fs->move_area_files_to_new_context($oldcontext->id,
2562                     $newcontext->id, 'mod_forum', 'post', $post->id);
2563             $attachmentsmoved = $fs->move_area_files_to_new_context($oldcontext->id,
2564                     $newcontext->id, 'mod_forum', 'attachment', $post->id);
2565             if ($attachmentsmoved > 0 && $post->attachment != '1') {
2566                 // Weird - let's fix it
2567                 $post->attachment = '1';
2568                 $DB->update_record('forum_posts', $post);
2569             } else if ($attachmentsmoved == 0 && $post->attachment != '') {
2570                 // Weird - let's fix it
2571                 $post->attachment = '';
2572                 $DB->update_record('forum_posts', $post);
2573             }
2574         }
2575     }
2576
2577     return true;
2578 }
2579
2580 /**
2581  * Returns attachments as formated text/html optionally with separate images
2582  *
2583  * @global object
2584  * @global object
2585  * @global object
2586  * @param object $post
2587  * @param object $cm
2588  * @param string $type html/text/separateimages
2589  * @return mixed string or array of (html text withouth images and image HTML)
2590  */
2591 function forum_print_attachments($post, $cm, $type) {
2592     global $CFG, $DB, $USER, $OUTPUT;
2593
2594     if (empty($post->attachment)) {
2595         return $type !== 'separateimages' ? '' : array('', '');
2596     }
2597
2598     if (!in_array($type, array('separateimages', 'html', 'text'))) {
2599         return $type !== 'separateimages' ? '' : array('', '');
2600     }
2601
2602     if (!$context = context_module::instance($cm->id)) {
2603         return $type !== 'separateimages' ? '' : array('', '');
2604     }
2605     $strattachment = get_string('attachment', 'forum');
2606
2607     $fs = get_file_storage();
2608
2609     $imagereturn = '';
2610     $output = '';
2611
2612     $canexport = !empty($CFG->enableportfolios) && (has_capability('mod/forum:exportpost', $context) || ($post->userid == $USER->id && has_capability('mod/forum:exportownpost', $context)));
2613
2614     if ($canexport) {
2615         require_once($CFG->libdir.'/portfoliolib.php');
2616     }
2617
2618     // We retrieve all files according to the time that they were created.  In the case that several files were uploaded
2619     // at the sametime (e.g. in the case of drag/drop upload) we revert to using the filename.
2620     $files = $fs->get_area_files($context->id, 'mod_forum', 'attachment', $post->id, "filename", false);
2621     if ($files) {
2622         if ($canexport) {
2623             $button = new portfolio_add_button();
2624         }
2625         foreach ($files as $file) {
2626             $filename = $file->get_filename();
2627             $mimetype = $file->get_mimetype();
2628             $iconimage = $OUTPUT->pix_icon(file_file_icon($file), get_mimetype_description($file), 'moodle', array('class' => 'icon'));
2629             $path = file_encode_url($CFG->wwwroot.'/pluginfile.php', '/'.$context->id.'/mod_forum/attachment/'.$post->id.'/'.$filename);
2630
2631             if ($type == 'html') {
2632                 $output .= "<a href=\"$path\">$iconimage</a> ";
2633                 $output .= "<a href=\"$path\">".s($filename)."</a>";
2634                 if ($canexport) {
2635                     $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
2636                     $button->set_format_by_file($file);
2637                     $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
2638                 }
2639                 $output .= "<br />";
2640
2641             } else if ($type == 'text') {
2642                 $output .= "$strattachment ".s($filename).":\n$path\n";
2643
2644             } else { //'returnimages'
2645                 if (in_array($mimetype, array('image/gif', 'image/jpeg', 'image/png'))) {
2646                     // Image attachments don't get printed as links
2647                     $imagereturn .= "<br /><img src=\"$path\" alt=\"\" />";
2648                     if ($canexport) {
2649                         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
2650                         $button->set_format_by_file($file);
2651                         $imagereturn .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
2652                     }
2653                 } else {
2654                     $output .= "<a href=\"$path\">$iconimage</a> ";
2655                     $output .= format_text("<a href=\"$path\">".s($filename)."</a>", FORMAT_HTML, array('context'=>$context));
2656                     if ($canexport) {
2657                         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
2658                         $button->set_format_by_file($file);
2659                         $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
2660                     }
2661                     $output .= '<br />';
2662                 }
2663             }
2664
2665             if (!empty($CFG->enableplagiarism)) {
2666                 require_once($CFG->libdir.'/plagiarismlib.php');
2667                 $output .= plagiarism_get_links(array('userid' => $post->userid,
2668                     'file' => $file,
2669                     'cmid' => $cm->id,
2670                     'course' => $cm->course,
2671                     'forum' => $cm->instance));
2672                 $output .= '<br />';
2673             }
2674         }
2675     }
2676
2677     if ($type !== 'separateimages') {
2678         return $output;
2679
2680     } else {
2681         return array($output, $imagereturn);
2682     }
2683 }
2684
2685 ////////////////////////////////////////////////////////////////////////////////
2686 // File API                                                                   //
2687 ////////////////////////////////////////////////////////////////////////////////
2688
2689 /**
2690  * Lists all browsable file areas
2691  *
2692  * @package  mod_forum
2693  * @category files
2694  * @param stdClass $course course object
2695  * @param stdClass $cm course module object
2696  * @param stdClass $context context object
2697  * @return array
2698  */
2699 function forum_get_file_areas($course, $cm, $context) {
2700     return array(
2701         'attachment' => get_string('areaattachment', 'mod_forum'),
2702         'post' => get_string('areapost', 'mod_forum'),
2703     );
2704 }
2705
2706 /**
2707  * File browsing support for forum module.
2708  *
2709  * @package  mod_forum
2710  * @category files
2711  * @param stdClass $browser file browser object
2712  * @param stdClass $areas file areas
2713  * @param stdClass $course course object
2714  * @param stdClass $cm course module
2715  * @param stdClass $context context module
2716  * @param string $filearea file area
2717  * @param int $itemid item ID
2718  * @param string $filepath file path
2719  * @param string $filename file name
2720  * @return file_info instance or null if not found
2721  */
2722 function forum_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
2723     global $CFG, $DB, $USER;
2724
2725     if ($context->contextlevel != CONTEXT_MODULE) {
2726         return null;
2727     }
2728
2729     // filearea must contain a real area
2730     if (!isset($areas[$filearea])) {
2731         return null;
2732     }
2733
2734     // Note that forum_user_can_see_post() additionally allows access for parent roles
2735     // and it explicitly checks qanda forum type, too. One day, when we stop requiring
2736     // course:managefiles, we will need to extend this.
2737     if (!has_capability('mod/forum:viewdiscussion', $context)) {
2738         return null;
2739     }
2740
2741     if (is_null($itemid)) {
2742         require_once($CFG->dirroot.'/mod/forum/locallib.php');
2743         return new forum_file_info_container($browser, $course, $cm, $context, $areas, $filearea);
2744     }
2745
2746     static $cached = array();
2747     // $cached will store last retrieved post, discussion and forum. To make sure that the cache
2748     // is cleared between unit tests we check if this is the same session
2749     if (!isset($cached['sesskey']) || $cached['sesskey'] != sesskey()) {
2750         $cached = array('sesskey' => sesskey());
2751     }
2752
2753     if (isset($cached['post']) && $cached['post']->id == $itemid) {
2754         $post = $cached['post'];
2755     } else if ($post = $DB->get_record('forum_posts', array('id' => $itemid))) {
2756         $cached['post'] = $post;
2757     } else {
2758         return null;
2759     }
2760
2761     if (isset($cached['discussion']) && $cached['discussion']->id == $post->discussion) {
2762         $discussion = $cached['discussion'];
2763     } else if ($discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion))) {
2764         $cached['discussion'] = $discussion;
2765     } else {
2766         return null;
2767     }
2768
2769     if (isset($cached['forum']) && $cached['forum']->id == $cm->instance) {
2770         $forum = $cached['forum'];
2771     } else if ($forum = $DB->get_record('forum', array('id' => $cm->instance))) {
2772         $cached['forum'] = $forum;
2773     } else {
2774         return null;
2775     }
2776
2777     $fs = get_file_storage();
2778     $filepath = is_null($filepath) ? '/' : $filepath;
2779     $filename = is_null($filename) ? '.' : $filename;
2780     if (!($storedfile = $fs->get_file($context->id, 'mod_forum', $filearea, $itemid, $filepath, $filename))) {
2781         return null;
2782     }
2783
2784     // Checks to see if the user can manage files or is the owner.
2785     // TODO MDL-33805 - Do not use userid here and move the capability check above.
2786     if (!has_capability('moodle/course:managefiles', $context) && $storedfile->get_userid() != $USER->id) {
2787         return null;
2788     }
2789     // Make sure groups allow this user to see this file
2790     if ($discussion->groupid > 0 && !has_capability('moodle/site:accessallgroups', $context)) {
2791         $groupmode = groups_get_activity_groupmode($cm, $course);
2792         if ($groupmode == SEPARATEGROUPS && !groups_is_member($discussion->groupid)) {
2793             return null;
2794         }
2795     }
2796
2797     // Make sure we're allowed to see it...
2798     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
2799         return null;
2800     }
2801
2802     $urlbase = $CFG->wwwroot.'/pluginfile.php';
2803     return new file_info_stored($browser, $context, $storedfile, $urlbase, $itemid, true, true, false, false);
2804 }
2805
2806 /**
2807  * Serves the forum attachments. Implements needed access control ;-)
2808  *
2809  * @package  mod_forum
2810  * @category files
2811  * @param stdClass $course course object
2812  * @param stdClass $cm course module object
2813  * @param stdClass $context context object
2814  * @param string $filearea file area
2815  * @param array $args extra arguments
2816  * @param bool $forcedownload whether or not force download
2817  * @param array $options additional options affecting the file serving
2818  * @return bool false if file not found, does not return if found - justsend the file
2819  */
2820 function forum_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
2821     global $CFG, $DB;
2822
2823     if ($context->contextlevel != CONTEXT_MODULE) {
2824         return false;
2825     }
2826
2827     require_course_login($course, true, $cm);
2828
2829     $areas = forum_get_file_areas($course, $cm, $context);
2830
2831     // filearea must contain a real area
2832     if (!isset($areas[$filearea])) {
2833         return false;
2834     }
2835
2836     $postid = (int)array_shift($args);
2837
2838     if (!$post = $DB->get_record('forum_posts', array('id'=>$postid))) {
2839         return false;
2840     }
2841
2842     if (!$discussion = $DB->get_record('forum_discussions', array('id'=>$post->discussion))) {
2843         return false;
2844     }
2845
2846     if (!$forum = $DB->get_record('forum', array('id'=>$cm->instance))) {
2847         return false;
2848     }
2849
2850     $fs = get_file_storage();
2851     $relativepath = implode('/', $args);
2852     $fullpath = "/$context->id/mod_forum/$filearea/$postid/$relativepath";
2853     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
2854         return false;
2855     }
2856
2857     // Make sure groups allow this user to see this file
2858     if ($discussion->groupid > 0) {
2859         $groupmode = groups_get_activity_groupmode($cm, $course);
2860         if ($groupmode == SEPARATEGROUPS) {
2861             if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
2862                 return false;
2863             }
2864         }
2865     }
2866
2867     // Make sure we're allowed to see it...
2868     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
2869         return false;
2870     }
2871
2872     // finally send the file
2873     send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
2874 }
2875
2876 /**
2877  * If successful, this function returns the name of the file
2878  *
2879  * @global object
2880  * @param object $post is a full post record, including course and forum
2881  * @param object $forum
2882  * @param object $cm
2883  * @param mixed $mform
2884  * @param string $unused
2885  * @return bool
2886  */
2887 function forum_add_attachment($post, $forum, $cm, $mform=null, $unused=null) {
2888     global $DB;
2889
2890     if (empty($mform)) {
2891         return false;
2892     }
2893
2894     if (empty($post->attachments)) {
2895         return true;   // Nothing to do
2896     }
2897
2898     $context = context_module::instance($cm->id);
2899
2900     $info = file_get_draft_area_info($post->attachments);
2901     $present = ($info['filecount']>0) ? '1' : '';
2902     file_save_draft_area_files($post->attachments, $context->id, 'mod_forum', 'attachment', $post->id,
2903             mod_forum_post_form::attachment_options($forum));
2904
2905     $DB->set_field('forum_posts', 'attachment', $present, array('id'=>$post->id));
2906
2907     return true;
2908 }
2909
2910 /**
2911  * Add a new post in an existing discussion.
2912  *
2913  * @param   stdClass    $post       The post data
2914  * @param   mixed       $mform      The submitted form
2915  * @param   string      $unused
2916  * @return int
2917  */
2918 function forum_add_new_post($post, $mform, $unused = null) {
2919     global $USER, $DB;
2920
2921     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion));
2922     $forum      = $DB->get_record('forum', array('id' => $discussion->forum));
2923     $cm         = get_coursemodule_from_instance('forum', $forum->id);
2924     $context    = context_module::instance($cm->id);
2925     $privatereplyto = 0;
2926
2927     // Check whether private replies should be enabled for this post.
2928     if ($post->parent) {
2929         $parent = $DB->get_record('forum_posts', array('id' => $post->parent));
2930
2931         if (!empty($parent->privatereplyto)) {
2932             throw new \coding_exception('It should not be possible to reply to a private reply');
2933         }
2934
2935         if (!empty($post->isprivatereply) && forum_user_can_reply_privately($context, $parent)) {
2936             $privatereplyto = $parent->userid;
2937         }
2938     }
2939
2940     $post->created    = $post->modified = time();
2941     $post->mailed     = FORUM_MAILED_PENDING;
2942     $post->userid     = $USER->id;
2943     $post->privatereplyto = $privatereplyto;
2944     $post->attachment = "";
2945     if (!isset($post->totalscore)) {
2946         $post->totalscore = 0;
2947     }
2948     if (!isset($post->mailnow)) {
2949         $post->mailnow    = 0;
2950     }
2951
2952     \mod_forum\local\entities\post::add_message_counts($post);
2953     $post->id = $DB->insert_record("forum_posts", $post);
2954     $post->message = file_save_draft_area_files($post->itemid, $context->id, 'mod_forum', 'post', $post->id,
2955             mod_forum_post_form::editor_options($context, null), $post->message);
2956     $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
2957     forum_add_attachment($post, $forum, $cm, $mform);
2958
2959     // Update discussion modified date
2960     $DB->set_field("forum_discussions", "timemodified", $post->modified, array("id" => $post->discussion));
2961     $DB->set_field("forum_discussions", "usermodified", $post->userid, array("id" => $post->discussion));
2962
2963     if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
2964         forum_tp_mark_post_read($post->userid, $post);
2965     }
2966
2967     if (isset($post->tags)) {
2968         core_tag_tag::set_item_tags('mod_forum', 'forum_posts', $post->id, $context, $post->tags);
2969     }
2970
2971     // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
2972     forum_trigger_content_uploaded_event($post, $cm, 'forum_add_new_post');
2973
2974     return $post->id;
2975 }
2976
2977 /**
2978  * Update a post.
2979  *
2980  * @param   stdClass    $newpost    The post to update
2981  * @param   mixed       $mform      The submitted form
2982  * @param   string      $unused
2983  * @return  bool
2984  */
2985 function forum_update_post($newpost, $mform, $unused = null) {
2986     global $DB, $USER;
2987
2988     $post       = $DB->get_record('forum_posts', array('id' => $newpost->id));
2989     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion));
2990     $forum      = $DB->get_record('forum', array('id' => $discussion->forum));
2991     $cm         = get_coursemodule_from_instance('forum', $forum->id);
2992     $context    = context_module::instance($cm->id);
2993
2994     // Allowed modifiable fields.
2995     $modifiablefields = [
2996         'subject',
2997         'message',
2998         'messageformat',
2999         'messagetrust',
3000         'timestart',
3001         'timeend',
3002         'pinned',
3003         'attachments',
3004     ];
3005     foreach ($modifiablefields as $field) {
3006         if (isset($newpost->{$field})) {
3007             $post->{$field} = $newpost->{$field};
3008         }
3009     }
3010     $post->modified = time();
3011
3012     if (!$post->parent) {   // Post is a discussion starter - update discussion title and times too
3013         $discussion->name      = $post->subject;
3014         $discussion->timestart = $post->timestart;
3015         $discussion->timeend   = $post->timeend;
3016
3017         if (isset($post->pinned)) {
3018             $discussion->pinned = $post->pinned;
3019         }
3020     }
3021     $post->message = file_save_draft_area_files($newpost->itemid, $context->id, 'mod_forum', 'post', $post->id,
3022             mod_forum_post_form::editor_options($context, $post->id), $post->message);
3023     \mod_forum\local\entities\post::add_message_counts($post);
3024     $DB->update_record('forum_posts', $post);
3025     // Note: Discussion modified time/user are intentionally not updated, to enable them to track the latest new post.
3026     $DB->update_record('forum_discussions', $discussion);
3027
3028     forum_add_attachment($post, $forum, $cm, $mform);
3029
3030     if (isset($newpost->tags)) {
3031         core_tag_tag::set_item_tags('mod_forum', 'forum_posts', $post->id, $context, $newpost->tags);
3032     }
3033
3034     if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
3035         forum_tp_mark_post_read($USER->id, $post);
3036     }
3037
3038     // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
3039     forum_trigger_content_uploaded_event($post, $cm, 'forum_update_post');
3040
3041     return true;
3042 }
3043
3044 /**
3045  * Given an object containing all the necessary data,
3046  * create a new discussion and return the id
3047  *
3048  * @param object $post
3049  * @param mixed $mform
3050  * @param string $unused
3051  * @param int $userid
3052  * @return object
3053  */
3054 function forum_add_discussion($discussion, $mform=null, $unused=null, $userid=null) {
3055     global $USER, $CFG, $DB;
3056
3057     $timenow = isset($discussion->timenow) ? $discussion->timenow : time();
3058
3059     if (is_null($userid)) {
3060         $userid = $USER->id;
3061     }
3062
3063     // The first post is stored as a real post, and linked
3064     // to from the discuss entry.
3065
3066     $forum = $DB->get_record('forum', array('id'=>$discussion->forum));
3067     $cm    = get_coursemodule_from_instance('forum', $forum->id);
3068
3069     $post = new stdClass();
3070     $post->discussion    = 0;
3071     $post->parent        = 0;
3072     $post->privatereplyto = 0;
3073     $post->userid        = $userid;
3074     $post->created       = $timenow;
3075     $post->modified      = $timenow;
3076     $post->mailed        = FORUM_MAILED_PENDING;
3077     $post->subject       = $discussion->name;
3078     $post->message       = $discussion->message;
3079     $post->messageformat = $discussion->messageformat;
3080     $post->messagetrust  = $discussion->messagetrust;
3081     $post->attachments   = isset($discussion->attachments) ? $discussion->attachments : null;
3082     $post->forum         = $forum->id;     // speedup
3083     $post->course        = $forum->course; // speedup
3084     $post->mailnow       = $discussion->mailnow;
3085
3086     \mod_forum\local\entities\post::add_message_counts($post);
3087     $post->id = $DB->insert_record("forum_posts", $post);
3088
3089     // TODO: Fix the calling code so that there always is a $cm when this function is called
3090     if (!empty($cm->id) && !empty($discussion->itemid)) {   // In "single simple discussions" this may not exist yet
3091         $context = context_module::instance($cm->id);
3092         $text = file_save_draft_area_files($discussion->itemid, $context->id, 'mod_forum', 'post', $post->id,
3093                 mod_forum_post_form::editor_options($context, null), $post->message);
3094         $DB->set_field('forum_posts', 'message', $text, array('id'=>$post->id));
3095     }
3096
3097     // Now do the main entry for the discussion, linking to this first post
3098
3099     $discussion->firstpost    = $post->id;
3100     $discussion->timemodified = $timenow;
3101     $discussion->usermodified = $post->userid;
3102     $discussion->userid       = $userid;
3103     $discussion->assessed     = 0;
3104
3105     $post->discussion = $DB->insert_record("forum_discussions", $discussion);
3106
3107     // Finally, set the pointer on the post.
3108     $DB->set_field("forum_posts", "discussion", $post->discussion, array("id"=>$post->id));
3109
3110     if (!empty($cm->id)) {
3111         forum_add_attachment($post, $forum, $cm, $mform, $unused);
3112     }
3113
3114     if (isset($discussion->tags)) {
3115         core_tag_tag::set_item_tags('mod_forum', 'forum_posts', $post->id, context_module::instance($cm->id), $discussion->tags);
3116     }
3117
3118     if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
3119         forum_tp_mark_post_read($post->userid, $post);
3120     }
3121
3122     // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
3123     if (!empty($cm->id)) {
3124         forum_trigger_content_uploaded_event($post, $cm, 'forum_add_discussion');
3125     }
3126
3127     return $post->discussion;
3128 }
3129
3130
3131 /**
3132  * Deletes a discussion and handles all associated cleanup.
3133  *
3134  * @global object
3135  * @param object $discussion Discussion to delete
3136  * @param bool $fulldelete True when deleting entire forum
3137  * @param object $course Course
3138  * @param object $cm Course-module
3139  * @param object $forum Forum
3140  * @return bool
3141  */
3142 function forum_delete_discussion($discussion, $fulldelete, $course, $cm, $forum) {
3143     global $DB, $CFG;
3144     require_once($CFG->libdir.'/completionlib.php');
3145
3146     $result = true;
3147
3148     if ($posts = $DB->get_records("forum_posts", array("discussion" => $discussion->id))) {
3149         foreach ($posts as $post) {
3150             $post->course = $discussion->course;
3151             $post->forum  = $discussion->forum;
3152             if (!forum_delete_post($post, 'ignore', $course, $cm, $forum, $fulldelete)) {
3153                 $result = false;
3154             }
3155         }
3156     }
3157
3158     forum_tp_delete_read_records(-1, -1, $discussion->id);
3159
3160     // Discussion subscriptions must be removed before discussions because of key constraints.
3161     $DB->delete_records('forum_discussion_subs', array('discussion' => $discussion->id));
3162     if (!$DB->delete_records("forum_discussions", array("id" => $discussion->id))) {
3163         $result = false;
3164     }
3165
3166     // Update completion state if we are tracking completion based on number of posts
3167     // But don't bother when deleting whole thing
3168     if (!$fulldelete) {
3169         $completion = new completion_info($course);
3170         if ($completion->is_enabled($cm) == COMPLETION_TRACKING_AUTOMATIC &&
3171            ($forum->completiondiscussions || $forum->completionreplies || $forum->completionposts)) {
3172             $completion->update_state($cm, COMPLETION_INCOMPLETE, $discussion->userid);
3173         }
3174     }
3175
3176     return $result;
3177 }
3178
3179
3180 /**
3181  * Deletes a single forum post.
3182  *
3183  * @global object
3184  * @param object $post Forum post object
3185  * @param mixed $children Whether to delete children. If false, returns false
3186  *   if there are any children (without deleting the post). If true,
3187  *   recursively deletes all children. If set to special value 'ignore', deletes
3188  *   post regardless of children (this is for use only when deleting all posts
3189  *   in a disussion).
3190  * @param object $course Course
3191  * @param object $cm Course-module
3192  * @param object $forum Forum
3193  * @param bool $skipcompletion True to skip updating completion state if it
3194  *   would otherwise be updated, i.e. when deleting entire forum anyway.
3195  * @return bool
3196  */
3197 function forum_delete_post($post, $children, $course, $cm, $forum, $skipcompletion=false) {
3198     global $DB, $CFG, $USER;
3199     require_once($CFG->libdir.'/completionlib.php');
3200
3201     $context = context_module::instance($cm->id);
3202
3203     if ($children !== 'ignore' && ($childposts = $DB->get_records('forum_posts', array('parent'=>$post->id)))) {
3204        if ($children) {
3205            foreach ($childposts as $childpost) {
3206                forum_delete_post($childpost, true, $course, $cm, $forum, $skipcompletion);
3207            }
3208        } else {
3209            return false;
3210        }
3211     }
3212
3213     // Delete ratings.
3214     require_once($CFG->dirroot.'/rating/lib.php');
3215     $delopt = new stdClass;
3216     $delopt->contextid = $context->id;
3217     $delopt->component = 'mod_forum';
3218     $delopt->ratingarea = 'post';
3219     $delopt->itemid = $post->id;
3220     $rm = new rating_manager();
3221     $rm->delete_ratings($delopt);
3222
3223     // Delete attachments.
3224     $fs = get_file_storage();
3225     $fs->delete_area_files($context->id, 'mod_forum', 'attachment', $post->id);
3226     $fs->delete_area_files($context->id, 'mod_forum', 'post', $post->id);
3227
3228     // Delete cached RSS feeds.
3229     if (!empty($CFG->enablerssfeeds)) {
3230         require_once($CFG->dirroot.'/mod/forum/rsslib.php');
3231         forum_rss_delete_file($forum);
3232     }
3233
3234     if ($DB->delete_records("forum_posts", array("id" => $post->id))) {
3235
3236         forum_tp_delete_read_records(-1, $post->id);
3237
3238     // Just in case we are deleting the last post
3239         forum_discussion_update_last_post($post->discussion);
3240
3241         // Update completion state if we are tracking completion based on number of posts
3242         // But don't bother when deleting whole thing
3243
3244         if (!$skipcompletion) {
3245             $completion = new completion_info($course);
3246             if ($completion->is_enabled($cm) == COMPLETION_TRACKING_AUTOMATIC &&
3247                ($forum->completiondiscussions || $forum->completionreplies || $forum->completionposts)) {
3248                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $post->userid);
3249             }
3250         }
3251
3252         $params = array(
3253             'context' => $context,
3254             'objectid' => $post->id,
3255             'other' => array(
3256                 'discussionid' => $post->discussion,
3257                 'forumid' => $forum->id,
3258                 'forumtype' => $forum->type,
3259             )
3260         );
3261         $post->deleted = 1;
3262         if ($post->userid !== $USER->id) {
3263             $params['relateduserid'] = $post->userid;
3264         }
3265         $event = \mod_forum\event\post_deleted::create($params);
3266         $event->add_record_snapshot('forum_posts', $post);
3267         $event->trigger();
3268
3269         return true;
3270     }
3271     return false;
3272 }
3273
3274 /**
3275  * Sends post content to plagiarism plugin
3276  * @param object $post Forum post object
3277  * @param object $cm Course-module
3278  * @param string $name
3279  * @return bool
3280 */
3281 function forum_trigger_content_uploaded_event($post, $cm, $name) {
3282     $context = context_module::instance($cm->id);
3283     $fs = get_file_storage();
3284     $files = $fs->get_area_files($context->id, 'mod_forum', 'attachment', $post->id, "timemodified", false);
3285     $params = array(
3286         'context' => $context,
3287         'objectid' => $post->id,
3288         'other' => array(
3289             'content' => $post->message,
3290             'pathnamehashes' => array_keys($files),
3291             'discussionid' => $post->discussion,
3292             'triggeredfrom' => $name,
3293         )
3294     );
3295     $event = \mod_forum\event\assessable_uploaded::create($params);
3296     $event->trigger();
3297     return true;
3298 }
3299
3300 /**
3301  * Given a new post, subscribes or unsubscribes as appropriate.
3302  * Returns some text which describes what happened.
3303  *
3304  * @param object $fromform The submitted form
3305  * @param stdClass $forum The forum record
3306  * @param stdClass $discussion The forum discussion record
3307  * @return string
3308  */
3309 function forum_post_subscription($fromform, $forum, $discussion) {
3310     global $USER;
3311
3312     if (\mod_forum\subscriptions::is_forcesubscribed($forum)) {
3313         return "";
3314     } else if (\mod_forum\subscriptions::subscription_disabled($forum)) {
3315         $subscribed = \mod_forum\subscriptions::is_subscribed($USER->id, $forum);
3316         if ($subscribed && !has_capability('moodle/course:manageactivities', context_course::instance($forum->course), $USER->id)) {
3317             // This user should not be subscribed to the forum.
3318             \mod_forum\subscriptions::unsubscribe_user($USER->id, $forum);
3319         }
3320         return "";
3321     }
3322
3323     $info = new stdClass();
3324     $info->name  = fullname($USER);
3325     $info->discussion = format_string($discussion->name);
3326     $info->forum = format_string($forum->name);
3327
3328     if (isset($fromform->discussionsubscribe) && $fromform->discussionsubscribe) {
3329         if ($result = \mod_forum\subscriptions::subscribe_user_to_discussion($USER->id, $discussion)) {
3330             return html_writer::tag('p', get_string('discussionnowsubscribed', 'forum', $info));
3331         }
3332     } else {
3333         if ($result = \mod_forum\subscriptions::unsubscribe_user_from_discussion($USER->id, $discussion)) {
3334             return html_writer::tag('p', get_string('discussionnownotsubscribed', 'forum', $info));
3335         }
3336     }
3337
3338     return '';
3339 }
3340
3341 /**
3342  * Generate and return the subscribe or unsubscribe link for a forum.
3343  *
3344  * @param object $forum the forum. Fields used are $forum->id and $forum->forcesubscribe.
3345  * @param object $context the context object for this forum.
3346  * @param array $messages text used for the link in its various states
3347  *      (subscribed, unsubscribed, forcesubscribed or cantsubscribe).
3348  *      Any strings not passed in are taken from the $defaultmessages array
3349  *      at the top of the function.
3350  * @param bool $cantaccessagroup
3351  * @param bool $unused1
3352  * @param bool $backtoindex
3353  * @param array $unused2
3354  * @return string
3355  */
3356 function forum_get_subscribe_link($forum, $context, $messages = array(), $cantaccessagroup = false, $unused1 = true,
3357     $backtoindex = false, $unused2 = null) {
3358     global $CFG, $USER, $PAGE, $OUTPUT;
3359     $defaultmessages = array(
3360         'subscribed' => get_string('unsubscribe', 'forum'),
3361         'unsubscribed' => get_string('subscribe', 'forum'),
3362         'cantaccessgroup' => get_string('no'),
3363         'forcesubscribed' => get_string('everyoneissubscribed', 'forum'),
3364         'cantsubscribe' => get_string('disallowsubscribe','forum')
3365     );
3366     $messages = $messages + $defaultmessages;
3367
3368     if (\mod_forum\subscriptions::is_forcesubscribed($forum)) {
3369         return $messages['forcesubscribed'];
3370     } else if (\mod_forum\subscriptions::subscription_disabled($forum) &&
3371             !has_capability('mod/forum:managesubscriptions', $context)) {
3372         return $messages['cantsubscribe'];
3373     } else if ($cantaccessagroup) {
3374         return $messages['cantaccessgroup'];
3375     } else {
3376         if (!is_enrolled($context, $USER, '', true)) {
3377             return '';
3378         }
3379
3380         $subscribed = \mod_forum\subscriptions::is_subscribed($USER->id, $forum);
3381         if ($subscribed) {
3382             $linktext = $messages['subscribed'];
3383             $linktitle = get_string('subscribestop', 'forum');
3384         } else {
3385             $linktext = $messages['unsubscribed'];
3386             $linktitle = get_string('subscribestart', 'forum');
3387         }
3388
3389         $options = array();
3390         if ($backtoindex) {
3391             $backtoindexlink = '&amp;backtoindex=1';
3392             $options['backtoindex'] = 1;
3393         } else {
3394             $backtoindexlink = '';
3395         }
3396
3397         $options['id'] = $forum->id;
3398         $options['sesskey'] = sesskey();
3399         $url = new moodle_url('/mod/forum/subscribe.php', $options);
3400         return $OUTPUT->single_button($url, $linktext, 'get', array('title' => $linktitle));
3401     }
3402 }
3403
3404 /**
3405  * Returns true if user created new discussion already.
3406  *
3407  * @param int $forumid  The forum to check for postings
3408  * @param int $userid   The user to check for postings
3409  * @param int $groupid  The group to restrict the check to
3410  * @return bool
3411  */
3412 function forum_user_has_posted_discussion($forumid, $userid, $groupid = null) {
3413     global $CFG, $DB;
3414
3415     $sql = "SELECT 'x'
3416               FROM {forum_discussions} d, {forum_posts} p
3417              WHERE d.forum = ? AND p.discussion = d.id AND p.parent = 0 AND p.userid = ?";
3418
3419     $params = [$forumid, $userid];
3420
3421     if ($groupid) {
3422         $sql .= " AND d.groupid = ?";
3423         $params[] = $groupid;
3424     }
3425
3426     return $DB->record_exists_sql($sql, $params);
3427 }
3428
3429 /**
3430  * @global object
3431  * @global object
3432  * @param int $forumid
3433  * @param int $userid
3434  * @return array
3435  */
3436 function forum_discussions_user_has_posted_in($forumid, $userid) {
3437     global $CFG, $DB;
3438
3439     $haspostedsql = "SELECT d.id AS id,
3440                             d.*
3441                        FROM {forum_posts} p,
3442                             {forum_discussions} d
3443                       WHERE p.discussion = d.id
3444                         AND d.forum = ?
3445                         AND p.userid = ?";
3446
3447     return $DB->get_records_sql($haspostedsql, array($forumid, $userid));
3448 }
3449
3450 /**
3451  * @global object
3452  * @global object
3453  * @param int $forumid
3454  * @param int $did
3455  * @param int $userid
3456  * @return bool
3457  */
3458 function forum_user_has_posted($forumid, $did, $userid) {
3459     global $DB;
3460
3461     if (empty($did)) {
3462         // posted in any forum discussion?
3463         $sql = "SELECT 'x'
3464                   FROM {forum_posts} p
3465                   JOIN {forum_discussions} d ON d.id = p.discussion
3466                  WHERE p.userid = :userid AND d.forum = :forumid";
3467         return $DB->record_exists_sql($sql, array('forumid'=>$forumid,'userid'=>$userid));
3468     } else {
3469         return $DB->record_exists('forum_posts', array('discussion'=>$did,'userid'=>$userid));
3470     }
3471 }
3472
3473 /**
3474  * Returns creation time of the first user's post in given discussion
3475  * @global object $DB
3476  * @param int $did Discussion id
3477  * @param int $userid User id
3478  * @return int|bool post creation time stamp or return false
3479  */
3480 function forum_get_user_posted_time($did, $userid) {
3481     global $DB;
3482
3483     $posttime = $DB->get_field('forum_posts', 'MIN(created)', array('userid'=>$userid, 'discussion'=>$did));
3484     if (empty($posttime)) {
3485         return false;
3486     }
3487     return $posttime;
3488 }
3489
3490 /**
3491  * @global object
3492  * @param object $forum
3493  * @param object $currentgroup
3494  * @param int $unused
3495  * @param object $cm
3496  * @param object $context
3497  * @return bool
3498  */
3499 function forum_user_can_post_discussion($forum, $currentgroup=null, $unused=-1, $cm=NULL, $context=NULL) {
3500 // $forum is an object
3501     global $USER;
3502
3503     // shortcut - guest and not-logged-in users can not post
3504     if (isguestuser() or !isloggedin()) {
3505         return false;
3506     }
3507
3508     if (!$cm) {
3509         debugging('missing cm', DEBUG_DEVELOPER);
3510         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
3511             print_error('invalidcoursemodule');
3512         }
3513     }
3514
3515     if (!$context) {
3516         $context = context_module::instance($cm->id);
3517     }
3518
3519     if (forum_is_cutoff_date_reached($forum)) {
3520         if (!has_capability('mod/forum:canoverridecutoff', $context)) {
3521             return false;
3522         }
3523     }
3524
3525     if ($currentgroup === null) {
3526         $currentgroup = groups_get_activity_group($cm);
3527     }
3528
3529     $groupmode = groups_get_activity_groupmode($cm);
3530
3531     if ($forum->type == 'news') {
3532         $capname = 'mod/forum:addnews';
3533     } else if ($forum->type == 'qanda') {
3534         $capname = 'mod/forum:addquestion';
3535     } else {
3536         $capname = 'mod/forum:startdiscussion';
3537     }
3538
3539     if (!has_capability($capname, $context)) {
3540         return false;
3541     }
3542
3543     if ($forum->type == 'single') {
3544         return false;
3545     }
3546
3547     if ($forum->type == 'eachuser') {
3548         if (forum_user_has_posted_discussion($forum->id, $USER->id, $currentgroup)) {
3549             return false;
3550         }
3551     }
3552
3553     if (!$groupmode or has_capability('moodle/site:accessallgroups', $context)) {
3554         return true;
3555     }
3556
3557     if ($currentgroup) {
3558         return groups_is_member($currentgroup);
3559     } else {
3560         // no group membership and no accessallgroups means no new discussions
3561         // reverted to 1.7 behaviour in 1.9+,  buggy in 1.8.0-1.9.0
3562         return false;
3563     }
3564 }
3565
3566 /**
3567  * This function checks whether the user can reply to posts in a forum
3568  * discussion. Use forum_user_can_post_discussion() to check whether the user
3569  * can start discussions.
3570  *
3571  * @global object
3572  * @global object
3573  * @uses DEBUG_DEVELOPER
3574  * @uses CONTEXT_MODULE
3575  * @uses VISIBLEGROUPS
3576  * @param object $forum forum object
3577  * @param object $discussion
3578  * @param object $user
3579  * @param object $cm
3580  * @param object $course
3581  * @param object $context
3582  * @return bool
3583  */
3584 function forum_user_can_post($forum, $discussion, $user=NULL, $cm=NULL, $course=NULL, $context=NULL) {
3585     global $USER, $DB;
3586     if (empty($user)) {
3587         $user = $USER;
3588     }
3589
3590     // shortcut - guest and not-logged-in users can not post
3591     if (isguestuser($user) or empty($user->id)) {
3592         return false;
3593     }
3594
3595     if (!isset($discussion->groupid)) {
3596         debugging('incorrect discussion parameter', DEBUG_DEVELOPER);
3597         return false;
3598     }
3599
3600     if (!$cm) {
3601         debugging('missing cm', DEBUG_DEVELOPER);
3602         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
3603             print_error('invalidcoursemodule');
3604         }
3605     }
3606
3607     if (!$course) {
3608         debugging('missing course', DEBUG_DEVELOPER);
3609         if (!$course = $DB->get_record('course', array('id' => $forum->course))) {
3610             print_error('invalidcourseid');
3611         }
3612     }
3613
3614     if (!$context) {
3615         $context = context_module::instance($cm->id);
3616     }
3617
3618     if (forum_is_cutoff_date_reached($forum)) {
3619         if (!has_capability('mod/forum:canoverridecutoff', $context)) {
3620             return false;
3621         }
3622     }
3623
3624     // Check whether the discussion is locked.
3625     if (forum_discussion_is_locked($forum, $discussion)) {
3626         if (!has_capability('mod/forum:canoverridediscussionlock', $context)) {
3627        &n