5015625b46ee722ea119fd21512064d418c1b0fc
[moodle.git] / 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/>.
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  */
23 defined('MOODLE_INTERNAL') || die();
25 /** Include required files */
26 require_once(__DIR__ . '/deprecatedlib.php');
27 require_once($CFG->libdir.'/filelib.php');
29 /// CONSTANTS ///////////////////////////////////////////////////////////
31 define('FORUM_MODE_FLATOLDEST', 1);
32 define('FORUM_MODE_FLATNEWEST', -1);
33 define('FORUM_MODE_THREADED', 2);
34 define('FORUM_MODE_NESTED', 3);
36 define('FORUM_CHOOSESUBSCRIBE', 0);
37 define('FORUM_FORCESUBSCRIBE', 1);
38 define('FORUM_INITIALSUBSCRIBE', 2);
39 define('FORUM_DISALLOWSUBSCRIBE',3);
41 /**
42  * FORUM_TRACKING_OFF - Tracking is not available for this forum.
43  */
44 define('FORUM_TRACKING_OFF', 0);
46 /**
47  * FORUM_TRACKING_OPTIONAL - Tracking is based on user preference.
48  */
49 define('FORUM_TRACKING_OPTIONAL', 1);
51 /**
52  * FORUM_TRACKING_FORCED - Tracking is on, regardless of user setting.
53  * Treated as FORUM_TRACKING_OPTIONAL if $CFG->forum_allowforcedreadtracking is off.
54  */
55 define('FORUM_TRACKING_FORCED', 2);
57 define('FORUM_MAILED_PENDING', 0);
58 define('FORUM_MAILED_SUCCESS', 1);
59 define('FORUM_MAILED_ERROR', 2);
61 if (!defined('FORUM_CRON_USER_CACHE')) {
62     /** Defines how many full user records are cached in forum cron. */
63     define('FORUM_CRON_USER_CACHE', 5000);
64 }
66 /**
67  * FORUM_POSTS_ALL_USER_GROUPS - All the posts in groups where the user is enrolled.
68  */
69 define('FORUM_POSTS_ALL_USER_GROUPS', -2);
71 define('FORUM_DISCUSSION_PINNED', 1);
72 define('FORUM_DISCUSSION_UNPINNED', 0);
74 /// STANDARD FUNCTIONS ///////////////////////////////////////////////////////////
76 /**
77  * Given an object containing all the necessary data,
78  * (defined by the form in mod_form.php) this function
79  * will create a new instance and return the id number
80  * of the new instance.
81  *
82  * @param stdClass $forum add forum instance
83  * @param mod_forum_mod_form $mform
84  * @return int intance id
85  */
86 function forum_add_instance($forum, $mform = null) {
87     global $CFG, $DB;
89     require_once($CFG->dirroot.'/mod/forum/locallib.php');
91     $forum->timemodified = time();
93     if (empty($forum->assessed)) {
94         $forum->assessed = 0;
95     }
97     if (empty($forum->ratingtime) or empty($forum->assessed)) {
98         $forum->assesstimestart  = 0;
99         $forum->assesstimefinish = 0;
100     }
102     $forum->id = $DB->insert_record('forum', $forum);
103     $modcontext = context_module::instance($forum->coursemodule);
105     if ($forum->type == 'single') {  // Create related discussion.
106         $discussion = new stdClass();
107         $discussion->course        = $forum->course;
108         $discussion->forum         = $forum->id;
109         $discussion->name          = $forum->name;
110         $discussion->assessed      = $forum->assessed;
111         $discussion->message       = $forum->intro;
112         $discussion->messageformat = $forum->introformat;
113         $discussion->messagetrust  = trusttext_trusted(context_course::instance($forum->course));
114         $discussion->mailnow       = false;
115         $discussion->groupid       = -1;
117         $message = '';
119         $discussion->id = forum_add_discussion($discussion, null, $message);
121         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
122             // Ugly hack - we need to copy the files somehow.
123             $discussion = $DB->get_record('forum_discussions', array('id'=>$discussion->id), '*', MUST_EXIST);
124             $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
126             $options = array('subdirs'=>true); // Use the same options as intro field!
127             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
128             $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
129         }
130     }
132     forum_update_calendar($forum, $forum->coursemodule);
133     forum_grade_item_update($forum);
135     $completiontimeexpected = !empty($forum->completionexpected) ? $forum->completionexpected : null;
136     \core_completion\api::update_completion_date_event($forum->coursemodule, 'forum', $forum->id, $completiontimeexpected);
138     return $forum->id;
141 /**
142  * Handle changes following the creation of a forum instance.
143  * This function is typically called by the course_module_created observer.
144  *
145  * @param object $context the forum context
146  * @param stdClass $forum The forum object
147  * @return void
148  */
149 function forum_instance_created($context, $forum) {
150     if ($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) {
151         $users = \mod_forum\subscriptions::get_potential_subscribers($context, 0, 'u.id, u.email');
152         foreach ($users as $user) {
153             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $context);
154         }
155     }
158 /**
159  * Given an object containing all the necessary data,
160  * (defined by the form in mod_form.php) this function
161  * will update an existing instance with new data.
162  *
163  * @global object
164  * @param object $forum forum instance (with magic quotes)
165  * @return bool success
166  */
167 function forum_update_instance($forum, $mform) {
168     global $CFG, $DB, $OUTPUT, $USER;
170     require_once($CFG->dirroot.'/mod/forum/locallib.php');
172     $forum->timemodified = time();
173     $forum->id           = $forum->instance;
175     if (empty($forum->assessed)) {
176         $forum->assessed = 0;
177     }
179     if (empty($forum->ratingtime) or empty($forum->assessed)) {
180         $forum->assesstimestart  = 0;
181         $forum->assesstimefinish = 0;
182     }
184     $oldforum = $DB->get_record('forum', array('id'=>$forum->id));
186     // MDL-3942 - if the aggregation type or scale (i.e. max grade) changes then recalculate the grades for the entire forum
187     // if  scale changes - do we need to recheck the ratings, if ratings higher than scale how do we want to respond?
188     // 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
189     if (($oldforum->assessed<>$forum->assessed) or ($oldforum->scale<>$forum->scale)) {
190         forum_update_grades($forum); // recalculate grades for the forum
191     }
193     if ($forum->type == 'single') {  // Update related discussion and post.
194         $discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id), 'timemodified ASC');
195         if (!empty($discussions)) {
196             if (count($discussions) > 1) {
197                 echo $OUTPUT->notification(get_string('warnformorepost', 'forum'));
198             }
199             $discussion = array_pop($discussions);
200         } else {
201             // try to recover by creating initial discussion - MDL-16262
202             $discussion = new stdClass();
203             $discussion->course          = $forum->course;
204             $discussion->forum           = $forum->id;
205             $discussion->name            = $forum->name;
206             $discussion->assessed        = $forum->assessed;
207             $discussion->message         = $forum->intro;
208             $discussion->messageformat   = $forum->introformat;
209             $discussion->messagetrust    = true;
210             $discussion->mailnow         = false;
211             $discussion->groupid         = -1;
213             $message = '';
215             forum_add_discussion($discussion, null, $message);
217             if (! $discussion = $DB->get_record('forum_discussions', array('forum'=>$forum->id))) {
218                 print_error('cannotadd', 'forum');
219             }
220         }
221         if (! $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost))) {
222             print_error('cannotfindfirstpost', 'forum');
223         }
225         $cm         = get_coursemodule_from_instance('forum', $forum->id);
226         $modcontext = context_module::instance($cm->id, MUST_EXIST);
228         $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
229         $post->subject       = $forum->name;
230         $post->message       = $forum->intro;
231         $post->messageformat = $forum->introformat;
232         $post->messagetrust  = trusttext_trusted($modcontext);
233         $post->modified      = $forum->timemodified;
234         $post->userid        = $USER->id;    // MDL-18599, so that current teacher can take ownership of activities.
236         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
237             // Ugly hack - we need to copy the files somehow.
238             $options = array('subdirs'=>true); // Use the same options as intro field!
239             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
240         }
242         $DB->update_record('forum_posts', $post);
243         $discussion->name = $forum->name;
244         $DB->update_record('forum_discussions', $discussion);
245     }
247     $DB->update_record('forum', $forum);
249     $modcontext = context_module::instance($forum->coursemodule);
250     if (($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) && ($oldforum->forcesubscribe <> $forum->forcesubscribe)) {
251         $users = \mod_forum\subscriptions::get_potential_subscribers($modcontext, 0, 'u.id, u.email', '');
252         foreach ($users as $user) {
253             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $modcontext);
254         }
255     }
257     forum_update_calendar($forum, $forum->coursemodule);
258     forum_grade_item_update($forum);
260     $completiontimeexpected = !empty($forum->completionexpected) ? $forum->completionexpected : null;
261     \core_completion\api::update_completion_date_event($forum->coursemodule, 'forum', $forum->id, $completiontimeexpected);
263     return true;
267 /**
268  * Given an ID of an instance of this module,
269  * this function will permanently delete the instance
270  * and any data that depends on it.
271  *
272  * @global object
273  * @param int $id forum instance id
274  * @return bool success
275  */
276 function forum_delete_instance($id) {
277     global $DB;
279     if (!$forum = $DB->get_record('forum', array('id'=>$id))) {
280         return false;
281     }
282     if (!$cm = get_coursemodule_from_instance('forum', $forum->id)) {
283         return false;
284     }
285     if (!$course = $DB->get_record('course', array('id'=>$cm->course))) {
286         return false;
287     }
289     $context = context_module::instance($cm->id);
291     // now get rid of all files
292     $fs = get_file_storage();
293     $fs->delete_area_files($context->id);
295     $result = true;
297     \core_completion\api::update_completion_date_event($cm->id, 'forum', $forum->id, null);
299     // Delete digest and subscription preferences.
300     $DB->delete_records('forum_digests', array('forum' => $forum->id));
301     $DB->delete_records('forum_subscriptions', array('forum'=>$forum->id));
302     $DB->delete_records('forum_discussion_subs', array('forum' => $forum->id));
304     if ($discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id))) {
305         foreach ($discussions as $discussion) {
306             if (!forum_delete_discussion($discussion, true, $course, $cm, $forum)) {
307                 $result = false;
308             }
309         }
310     }
312     forum_tp_delete_read_records(-1, -1, -1, $forum->id);
314     forum_grade_item_delete($forum);
316     // We must delete the module record after we delete the grade item.
317     if (!$DB->delete_records('forum', array('id'=>$forum->id))) {
318         $result = false;
319     }
321     return $result;
325 /**
326  * Indicates API features that the forum supports.
327  *
328  * @uses FEATURE_GROUPS
329  * @uses FEATURE_GROUPINGS
330  * @uses FEATURE_MOD_INTRO
331  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
332  * @uses FEATURE_COMPLETION_HAS_RULES
333  * @uses FEATURE_GRADE_HAS_GRADE
334  * @uses FEATURE_GRADE_OUTCOMES
335  * @param string $feature
336  * @return mixed True if yes (some features may use other values)
337  */
338 function forum_supports($feature) {
339     switch($feature) {
340         case FEATURE_GROUPS:                  return true;
341         case FEATURE_GROUPINGS:               return true;
342         case FEATURE_MOD_INTRO:               return true;
343         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
344         case FEATURE_COMPLETION_HAS_RULES:    return true;
345         case FEATURE_GRADE_HAS_GRADE:         return true;
346         case FEATURE_GRADE_OUTCOMES:          return true;
347         case FEATURE_RATE:                    return true;
348         case FEATURE_BACKUP_MOODLE2:          return true;
349         case FEATURE_SHOW_DESCRIPTION:        return true;
350         case FEATURE_PLAGIARISM:              return true;
352         default: return null;
353     }
357 /**
358  * Obtains the automatic completion state for this forum based on any conditions
359  * in forum settings.
360  *
361  * @global object
362  * @global object
363  * @param object $course Course
364  * @param object $cm Course-module
365  * @param int $userid User ID
366  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
367  * @return bool True if completed, false if not. (If no conditions, then return
368  *   value depends on comparison type)
369  */
370 function forum_get_completion_state($course,$cm,$userid,$type) {
371     global $CFG,$DB;
373     // Get forum details
374     if (!($forum=$DB->get_record('forum',array('id'=>$cm->instance)))) {
375         throw new Exception("Can't find forum {$cm->instance}");
376     }
378     $result=$type; // Default return value
380     $postcountparams=array('userid'=>$userid,'forumid'=>$forum->id);
381     $postcountsql="
382 SELECT
383     COUNT(1)
384 FROM
385     {forum_posts} fp
386     INNER JOIN {forum_discussions} fd ON fp.discussion=fd.id
387 WHERE
388     fp.userid=:userid AND fd.forum=:forumid";
390     if ($forum->completiondiscussions) {
391         $value = $forum->completiondiscussions <=
392                  $DB->count_records('forum_discussions',array('forum'=>$forum->id,'userid'=>$userid));
393         if ($type == COMPLETION_AND) {
394             $result = $result && $value;
395         } else {
396             $result = $result || $value;
397         }
398     }
399     if ($forum->completionreplies) {
400         $value = $forum->completionreplies <=
401                  $DB->get_field_sql( $postcountsql.' AND fp.parent<>0',$postcountparams);
402         if ($type==COMPLETION_AND) {
403             $result = $result && $value;
404         } else {
405             $result = $result || $value;
406         }
407     }
408     if ($forum->completionposts) {
409         $value = $forum->completionposts <= $DB->get_field_sql($postcountsql,$postcountparams);
410         if ($type == COMPLETION_AND) {
411             $result = $result && $value;
412         } else {
413             $result = $result || $value;
414         }
415     }
417     return $result;
420 /**
421  * Create a message-id string to use in the custom headers of forum notification emails
422  *
423  * message-id is used by email clients to identify emails and to nest conversations
424  *
425  * @param int $postid The ID of the forum post we are notifying the user about
426  * @param int $usertoid The ID of the user being notified
427  * @return string A unique message-id
428  */
429 function forum_get_email_message_id($postid, $usertoid) {
430     return generate_email_messageid(hash('sha256', $postid . 'to' . $usertoid));
433 /**
434  *
435  * @param object $course
436  * @param object $user
437  * @param object $mod TODO this is not used in this function, refactor
438  * @param object $forum
439  * @return object A standard object with 2 variables: info (number of posts for this user) and time (last modified)
440  */
441 function forum_user_outline($course, $user, $mod, $forum) {
442     global $CFG;
443     require_once("$CFG->libdir/gradelib.php");
444     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
445     if (empty($grades->items[0]->grades)) {
446         $grade = false;
447     } else {
448         $grade = reset($grades->items[0]->grades);
449     }
451     $count = forum_count_user_posts($forum->id, $user->id);
453     if ($count && $count->postcount > 0) {
454         $result = new stdClass();
455         $result->info = get_string("numposts", "forum", $count->postcount);
456         $result->time = $count->lastpost;
457         if ($grade) {
458             if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {
459                 $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
460             } else {
461                 $result->info = get_string('grade') . ': ' . get_string('hidden', 'grades');
462             }
463         }
464         return $result;
465     } else if ($grade) {
466         $result = new stdClass();
467         if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {
468             $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
469         } else {
470             $result->info = get_string('grade') . ': ' . get_string('hidden', 'grades');
471         }
473         //datesubmitted == time created. dategraded == time modified or time overridden
474         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
475         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
476         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
477             $result->time = $grade->dategraded;
478         } else {
479             $result->time = $grade->datesubmitted;
480         }
482         return $result;
483     }
484     return NULL;
488 /**
489  * @global object
490  * @global object
491  * @param object $coure
492  * @param object $user
493  * @param object $mod
494  * @param object $forum
495  */
496 function forum_user_complete($course, $user, $mod, $forum) {
497     global $CFG,$USER, $OUTPUT;
498     require_once("$CFG->libdir/gradelib.php");
500     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
501     if (!empty($grades->items[0]->grades)) {
502         $grade = reset($grades->items[0]->grades);
503         if (!$grade->hidden || has_capability('moodle/grade:viewhidden', context_course::instance($course->id))) {
504             echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
505             if ($grade->str_feedback) {
506                 echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
507             }
508         } else {
509             echo $OUTPUT->container(get_string('grade') . ': ' . get_string('hidden', 'grades'));
510         }
511     }
513     if ($posts = forum_get_user_posts($forum->id, $user->id)) {
515         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $course->id)) {
516             print_error('invalidcoursemodule');
517         }
518         $context = context_module::instance($cm->id);
519         $discussions = forum_get_user_involved_discussions($forum->id, $user->id);
520         $posts = array_filter($posts, function($post) use ($discussions) {
521             return isset($discussions[$post->discussion]);
522         });
523         $entityfactory = mod_forum\local\container::get_entity_factory();
524         $rendererfactory = mod_forum\local\container::get_renderer_factory();
525         $postrenderer = $rendererfactory->get_posts_renderer();
527         echo $postrenderer->render(
528             $USER,
529             [$forum->id => $entityfactory->get_forum_from_stdclass($forum, $context, $cm, $course)],
530             array_map(function($discussion) use ($entityfactory) {
531                 return $entityfactory->get_discussion_from_stdclass($discussion);
532             }, $discussions),
533             array_map(function($post) use ($entityfactory) {
534                 return $entityfactory->get_post_from_stdclass($post);
535             }, $posts)
536         );
537     } else {
538         echo "<p>".get_string("noposts", "forum")."</p>";
539     }
542 /**
543  * Filters the forum discussions according to groups membership and config.
544  *
545  * @deprecated since 3.3
546  * @todo The final deprecation of this function will take place in Moodle 3.7 - see MDL-57487.
547  * @since  Moodle 2.8, 2.7.1, 2.6.4
548  * @param  array $discussions Discussions with new posts array
549  * @return array Forums with the number of new posts
550  */
551 function forum_filter_user_groups_discussions($discussions) {
553     debugging('The function forum_filter_user_groups_discussions() is now deprecated.', DEBUG_DEVELOPER);
555     // Group the remaining discussions posts by their forumid.
556     $filteredforums = array();
558     // Discard not visible groups.
559     foreach ($discussions as $discussion) {
561         // Course data is already cached.
562         $instances = get_fast_modinfo($discussion->course)->get_instances();
563         $forum = $instances['forum'][$discussion->forum];
565         // Continue if the user should not see this discussion.
566         if (!forum_is_user_group_discussion($forum, $discussion->groupid)) {
567             continue;
568         }
570         // Grouping results by forum.
571         if (empty($filteredforums[$forum->instance])) {
572             $filteredforums[$forum->instance] = new stdClass();
573             $filteredforums[$forum->instance]->id = $forum->id;
574             $filteredforums[$forum->instance]->count = 0;
575         }
576         $filteredforums[$forum->instance]->count += $discussion->count;
578     }
580     return $filteredforums;
583 /**
584  * Returns whether the discussion group is visible by the current user or not.
585  *
586  * @since Moodle 2.8, 2.7.1, 2.6.4
587  * @param cm_info $cm The discussion course module
588  * @param int $discussiongroupid The discussion groupid
589  * @return bool
590  */
591 function forum_is_user_group_discussion(cm_info $cm, $discussiongroupid) {
593     if ($discussiongroupid == -1 || $cm->effectivegroupmode != SEPARATEGROUPS) {
594         return true;
595     }
597     if (isguestuser()) {
598         return false;
599     }
601     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id)) ||
602             in_array($discussiongroupid, $cm->get_modinfo()->get_groups($cm->groupingid))) {
603         return true;
604     }
606     return false;
609 /**
610  * @deprecated since 3.3
611  * @todo The final deprecation of this function will take place in Moodle 3.7 - see MDL-57487.
612  * @global object
613  * @global object
614  * @global object
615  * @param array $courses
616  * @param array $htmlarray
617  */
618 function forum_print_overview($courses,&$htmlarray) {
619     global $USER, $CFG, $DB, $SESSION;
621     debugging('The function forum_print_overview() is now deprecated.', DEBUG_DEVELOPER);
623     if (empty($courses) || !is_array($courses) || count($courses) == 0) {
624         return array();
625     }
627     if (!$forums = get_all_instances_in_courses('forum',$courses)) {
628         return;
629     }
631     // Courses to search for new posts
632     $coursessqls = array();
633     $params = array();
634     foreach ($courses as $course) {
636         // If the user has never entered into the course all posts are pending
637         if ($course->lastaccess == 0) {
638             $coursessqls[] = '(d.course = ?)';
639             $params[] = $course->id;
641         // Only posts created after the course last access
642         } else {
643             $coursessqls[] = '(d.course = ? AND p.created > ?)';
644             $params[] = $course->id;
645             $params[] = $course->lastaccess;
646         }
647     }
648     $params[] = $USER->id;
649     $coursessql = implode(' OR ', $coursessqls);
651     $sql = "SELECT d.id, d.forum, d.course, d.groupid, COUNT(*) as count "
652                 .'FROM {forum_discussions} d '
653                 .'JOIN {forum_posts} p ON p.discussion = d.id '
654                 ."WHERE ($coursessql) "
655                 .'AND p.deleted <> 1 '
656                 .'AND p.userid != ? '
657                 .'AND (d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?)) '
658                 .'GROUP BY d.id, d.forum, d.course, d.groupid '
659                 .'ORDER BY d.course, d.forum';
660     $params[] = time();
661     $params[] = time();
663     // Avoid warnings.
664     if (!$discussions = $DB->get_records_sql($sql, $params)) {
665         $discussions = array();
666     }
668     $forumsnewposts = forum_filter_user_groups_discussions($discussions);
670     // also get all forum tracking stuff ONCE.
671     $trackingforums = array();
672     foreach ($forums as $forum) {
673         if (forum_tp_can_track_forums($forum)) {
674             $trackingforums[$forum->id] = $forum;
675         }
676     }
678     if (count($trackingforums) > 0) {
679         $cutoffdate = isset($CFG->forum_oldpostdays) ? (time() - ($CFG->forum_oldpostdays*24*60*60)) : 0;
680         $sql = 'SELECT d.forum,d.course,COUNT(p.id) AS count '.
681             ' FROM {forum_posts} p '.
682             ' JOIN {forum_discussions} d ON p.discussion = d.id '.
683             ' LEFT JOIN {forum_read} r ON r.postid = p.id AND r.userid = ? WHERE p.deleted <> 1 AND (';
684         $params = array($USER->id);
686         foreach ($trackingforums as $track) {
687             $sql .= '(d.forum = ? AND (d.groupid = -1 OR d.groupid = 0 OR d.groupid = ?)) OR ';
688             $params[] = $track->id;
689             if (isset($SESSION->currentgroup[$track->course])) {
690                 $groupid =  $SESSION->currentgroup[$track->course];
691             } else {
692                 // get first groupid
693                 $groupids = groups_get_all_groups($track->course, $USER->id);
694                 if ($groupids) {
695                     reset($groupids);
696                     $groupid = key($groupids);
697                     $SESSION->currentgroup[$track->course] = $groupid;
698                 } else {
699                     $groupid = 0;
700                 }
701                 unset($groupids);
702             }
703             $params[] = $groupid;
704         }
705         $sql = substr($sql,0,-3); // take off the last OR
706         $sql .= ') AND p.modified >= ? AND r.id is NULL ';
707         $sql .= 'AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)) ';
708         $sql .= 'GROUP BY d.forum,d.course';
709         $params[] = $cutoffdate;
710         $params[] = time();
711         $params[] = time();
713         if (!$unread = $DB->get_records_sql($sql, $params)) {
714             $unread = array();
715         }
716     } else {
717         $unread = array();
718     }
720     if (empty($unread) and empty($forumsnewposts)) {
721         return;
722     }
724     $strforum = get_string('modulename','forum');
726     foreach ($forums as $forum) {
727         $str = '';
728         $count = 0;
729         $thisunread = 0;
730         $showunread = false;
731         // either we have something from logs, or trackposts, or nothing.
732         if (array_key_exists($forum->id, $forumsnewposts) && !empty($forumsnewposts[$forum->id])) {
733             $count = $forumsnewposts[$forum->id]->count;
734         }
735         if (array_key_exists($forum->id,$unread)) {
736             $thisunread = $unread[$forum->id]->count;
737             $showunread = true;
738         }
739         if ($count > 0 || $thisunread > 0) {
740             $str .= '<div class="overview forum"><div class="name">'.$strforum.': <a title="'.$strforum.'" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.
741                 $forum->name.'</a></div>';
742             $str .= '<div class="info"><span class="postsincelogin">';
743             $str .= get_string('overviewnumpostssince', 'forum', $count)."</span>";
744             if (!empty($showunread)) {
745                 $str .= '<div class="unreadposts">'.get_string('overviewnumunread', 'forum', $thisunread).'</div>';
746             }
747             $str .= '</div></div>';
748         }
749         if (!empty($str)) {
750             if (!array_key_exists($forum->course,$htmlarray)) {
751                 $htmlarray[$forum->course] = array();
752             }
753             if (!array_key_exists('forum',$htmlarray[$forum->course])) {
754                 $htmlarray[$forum->course]['forum'] = ''; // initialize, avoid warnings
755             }
756             $htmlarray[$forum->course]['forum'] .= $str;
757         }
758     }
761 /**
762  * Given a course and a date, prints a summary of all the new
763  * messages posted in the course since that date
764  *
765  * @global object
766  * @global object
767  * @global object
768  * @uses CONTEXT_MODULE
769  * @uses VISIBLEGROUPS
770  * @param object $course
771  * @param bool $viewfullnames capability
772  * @param int $timestart
773  * @return bool success
774  */
775 function forum_print_recent_activity($course, $viewfullnames, $timestart) {
776     global $CFG, $USER, $DB, $OUTPUT;
778     // do not use log table if possible, it may be huge and is expensive to join with other tables
780     $allnamefields = user_picture::fields('u', null, 'duserid');
781     if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
782                                               d.timestart, d.timeend, $allnamefields
783                                          FROM {forum_posts} p
784                                               JOIN {forum_discussions} d ON d.id = p.discussion
785                                               JOIN {forum} f             ON f.id = d.forum
786                                               JOIN {user} u              ON u.id = p.userid
787                                         WHERE p.created > ? AND f.course = ? AND p.deleted <> 1
788                                      ORDER BY p.id ASC", array($timestart, $course->id))) { // order by initial posting date
789          return false;
790     }
792     $modinfo = get_fast_modinfo($course);
794     $groupmodes = array();
795     $cms    = array();
797     $strftimerecent = get_string('strftimerecent');
799     $printposts = array();
800     foreach ($posts as $post) {
801         if (!isset($modinfo->instances['forum'][$post->forum])) {
802             // not visible
803             continue;
804         }
805         $cm = $modinfo->instances['forum'][$post->forum];
806         if (!$cm->uservisible) {
807             continue;
808         }
809         $context = context_module::instance($cm->id);
811         if (!has_capability('mod/forum:viewdiscussion', $context)) {
812             continue;
813         }
815         if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
816           and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
817             if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
818                 continue;
819             }
820         }
822         if (!forum_post_is_visible_privately($post, $cm)) {
823             continue;
824         }
826         // Check that the user can see the discussion.
827         if (forum_is_user_group_discussion($cm, $post->groupid)) {
828             $printposts[] = $post;
829         }
831     }
832     unset($posts);
834     if (!$printposts) {
835         return false;
836     }
838     echo $OUTPUT->heading(get_string('newforumposts', 'forum').':', 3);
839     $list = html_writer::start_tag('ul', ['class' => 'unlist']);
841     foreach ($printposts as $post) {
842         $subjectclass = empty($post->parent) ? ' bold' : '';
843         $authorhidden = forum_is_author_hidden($post, (object) ['type' => $post->forumtype]);
845         $list .= html_writer::start_tag('li');
846         $list .= html_writer::start_div('head');
847         $list .= html_writer::div(userdate_htmltime($post->modified, $strftimerecent), 'date');
848         if (!$authorhidden) {
849             $list .= html_writer::div(fullname($post, $viewfullnames), 'name');
850         }
851         $list .= html_writer::end_div(); // Head.
853         $list .= html_writer::start_div('info' . $subjectclass);
854         $discussionurl = new moodle_url('/mod/forum/discuss.php', ['d' => $post->discussion]);
855         if (!empty($post->parent)) {
856             $discussionurl->param('parent', $post->parent);
857             $discussionurl->set_anchor('p'. $post->id);
858         }
859         $post->subject = break_up_long_words(format_string($post->subject, true));
860         $list .= html_writer::link($discussionurl, $post->subject, ['rel' => 'bookmark']);
861         $list .= html_writer::end_div(); // Info.
862         $list .= html_writer::end_tag('li');
863     }
865     $list .= html_writer::end_tag('ul');
866     echo $list;
868     return true;
871 /**
872  * Return grade for given user or all users.
873  *
874  * @global object
875  * @global object
876  * @param object $forum
877  * @param int $userid optional user id, 0 means all users
878  * @return array array of grades, false if none
879  */
880 function forum_get_user_grades($forum, $userid = 0) {
881     global $CFG;
883     require_once($CFG->dirroot.'/rating/lib.php');
885     $ratingoptions = new stdClass;
886     $ratingoptions->component = 'mod_forum';
887     $ratingoptions->ratingarea = 'post';
889     //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?
890     $ratingoptions->modulename = 'forum';
891     $ratingoptions->moduleid   = $forum->id;
892     $ratingoptions->userid = $userid;
893     $ratingoptions->aggregationmethod = $forum->assessed;
894     $ratingoptions->scaleid = $forum->scale;
895     $ratingoptions->itemtable = 'forum_posts';
896     $ratingoptions->itemtableusercolumn = 'userid';
898     $rm = new rating_manager();
899     return $rm->get_user_grades($ratingoptions);
902 /**
903  * Update activity grades
904  *
905  * @category grade
906  * @param object $forum
907  * @param int $userid specific user only, 0 means all
908  * @param boolean $nullifnone return null if grade does not exist
909  * @return void
910  */
911 function forum_update_grades($forum, $userid=0, $nullifnone=true) {
912     global $CFG, $DB;
913     require_once($CFG->libdir.'/gradelib.php');
915     if (!$forum->assessed) {
916         forum_grade_item_update($forum);
918     } else if ($grades = forum_get_user_grades($forum, $userid)) {
919         forum_grade_item_update($forum, $grades);
921     } else if ($userid and $nullifnone) {
922         $grade = new stdClass();
923         $grade->userid   = $userid;
924         $grade->rawgrade = NULL;
925         forum_grade_item_update($forum, $grade);
927     } else {
928         forum_grade_item_update($forum);
929     }
932 /**
933  * Create/update grade item for given forum
934  *
935  * @category grade
936  * @uses GRADE_TYPE_NONE
937  * @uses GRADE_TYPE_VALUE
938  * @uses GRADE_TYPE_SCALE
939  * @param stdClass $forum Forum object with extra cmidnumber
940  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
941  * @return int 0 if ok
942  */
943 function forum_grade_item_update($forum, $grades=NULL) {
944     global $CFG;
945     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
946         require_once($CFG->libdir.'/gradelib.php');
947     }
949     $params = array('itemname'=>$forum->name, 'idnumber'=>$forum->cmidnumber);
951     if (!$forum->assessed or $forum->scale == 0) {
952         $params['gradetype'] = GRADE_TYPE_NONE;
954     } else if ($forum->scale > 0) {
955         $params['gradetype'] = GRADE_TYPE_VALUE;
956         $params['grademax']  = $forum->scale;
957         $params['grademin']  = 0;
959     } else if ($forum->scale < 0) {
960         $params['gradetype'] = GRADE_TYPE_SCALE;
961         $params['scaleid']   = -$forum->scale;
962     }
964     if ($grades  === 'reset') {
965         $params['reset'] = true;
966         $grades = NULL;
967     }
969     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, $grades, $params);
972 /**
973  * Delete grade item for given forum
974  *
975  * @category grade
976  * @param stdClass $forum Forum object
977  * @return grade_item
978  */
979 function forum_grade_item_delete($forum) {
980     global $CFG;
981     require_once($CFG->libdir.'/gradelib.php');
983     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, NULL, array('deleted'=>1));
987 /**
988  * This function returns if a scale is being used by one forum
989  *
990  * @global object
991  * @param int $forumid
992  * @param int $scaleid negative number
993  * @return bool
994  */
995 function forum_scale_used ($forumid,$scaleid) {
996     global $DB;
997     $return = false;
999     $rec = $DB->get_record("forum",array("id" => "$forumid","scale" => "-$scaleid"));
1001     if (!empty($rec) && !empty($scaleid)) {
1002         $return = true;
1003     }
1005     return $return;
1008 /**
1009  * Checks if scale is being used by any instance of forum
1010  *
1011  * This is used to find out if scale used anywhere
1012  *
1013  * @global object
1014  * @param $scaleid int
1015  * @return boolean True if the scale is used by any forum
1016  */
1017 function forum_scale_used_anywhere($scaleid) {
1018     global $DB;
1019     if ($scaleid and $DB->record_exists('forum', array('scale' => -$scaleid))) {
1020         return true;
1021     } else {
1022         return false;
1023     }
1026 // SQL FUNCTIONS ///////////////////////////////////////////////////////////
1028 /**
1029  * Gets a post with all info ready for forum_print_post
1030  * Most of these joins are just to get the forum id
1031  *
1032  * @global object
1033  * @global object
1034  * @param int $postid
1035  * @return mixed array of posts or false
1036  */
1037 function forum_get_post_full($postid) {
1038     global $CFG, $DB;
1040     $allnames = get_all_user_name_fields(true, 'u');
1041     return $DB->get_record_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1042                              FROM {forum_posts} p
1043                                   JOIN {forum_discussions} d ON p.discussion = d.id
1044                                   LEFT JOIN {user} u ON p.userid = u.id
1045                             WHERE p.id = ?", array($postid));
1048 /**
1049  * Gets all posts in discussion including top parent.
1050  *
1051  * @param   int     $discussionid   The Discussion to fetch.
1052  * @param   string  $sort           The sorting to apply.
1053  * @param   bool    $tracking       Whether the user tracks this forum.
1054  * @return  array                   The posts in the discussion.
1055  */
1056 function forum_get_all_discussion_posts($discussionid, $sort, $tracking = false) {
1057     global $CFG, $DB, $USER;
1059     $tr_sel  = "";
1060     $tr_join = "";
1061     $params = array();
1063     if ($tracking) {
1064         $tr_sel  = ", fr.id AS postread";
1065         $tr_join = "LEFT JOIN {forum_read} fr ON (fr.postid = p.id AND fr.userid = ?)";
1066         $params[] = $USER->id;
1067     }
1069     $allnames = get_all_user_name_fields(true, 'u');
1070     $params[] = $discussionid;
1071     if (!$posts = $DB->get_records_sql("SELECT p.*, $allnames, u.email, u.picture, u.imagealt $tr_sel
1072                                      FROM {forum_posts} p
1073                                           LEFT JOIN {user} u ON p.userid = u.id
1074                                           $tr_join
1075                                     WHERE p.discussion = ?
1076                                  ORDER BY $sort", $params)) {
1077         return array();
1078     }
1080     foreach ($posts as $pid=>$p) {
1081         if ($tracking) {
1082             if (forum_tp_is_post_old($p)) {
1083                  $posts[$pid]->postread = true;
1084             }
1085         }
1086         if (!$p->parent) {
1087             continue;
1088         }
1089         if (!isset($posts[$p->parent])) {
1090             continue; // parent does not exist??
1091         }
1092         if (!isset($posts[$p->parent]->children)) {
1093             $posts[$p->parent]->children = array();
1094         }
1095         $posts[$p->parent]->children[$pid] =& $posts[$pid];
1096     }
1098     // Start with the last child of the first post.
1099     $post = &$posts[reset($posts)->id];
1101     $lastpost = false;
1102     while (!$lastpost) {
1103         if (!isset($post->children)) {
1104             $post->lastpost = true;
1105             $lastpost = true;
1106         } else {
1107              // Go to the last child of this post.
1108             $post = &$posts[end($post->children)->id];
1109         }
1110     }
1112     return $posts;
1115 /**
1116  * An array of forum objects that the user is allowed to read/search through.
1117  *
1118  * @global object
1119  * @global object
1120  * @global object
1121  * @param int $userid
1122  * @param int $courseid if 0, we look for forums throughout the whole site.
1123  * @return array of forum objects, or false if no matches
1124  *         Forum objects have the following attributes:
1125  *         id, type, course, cmid, cmvisible, cmgroupmode, accessallgroups,
1126  *         viewhiddentimedposts
1127  */
1128 function forum_get_readable_forums($userid, $courseid=0) {
1130     global $CFG, $DB, $USER;
1131     require_once($CFG->dirroot.'/course/lib.php');
1133     if (!$forummod = $DB->get_record('modules', array('name' => 'forum'))) {
1134         print_error('notinstalled', 'forum');
1135     }
1137     if ($courseid) {
1138         $courses = $DB->get_records('course', array('id' => $courseid));
1139     } else {
1140         // If no course is specified, then the user can see SITE + his courses.
1141         $courses1 = $DB->get_records('course', array('id' => SITEID));
1142         $courses2 = enrol_get_users_courses($userid, true, array('modinfo'));
1143         $courses = array_merge($courses1, $courses2);
1144     }
1145     if (!$courses) {
1146         return array();
1147     }
1149     $readableforums = array();
1151     foreach ($courses as $course) {
1153         $modinfo = get_fast_modinfo($course);
1155         if (empty($modinfo->instances['forum'])) {
1156             // hmm, no forums?
1157             continue;
1158         }
1160         $courseforums = $DB->get_records('forum', array('course' => $course->id));
1162         foreach ($modinfo->instances['forum'] as $forumid => $cm) {
1163             if (!$cm->uservisible or !isset($courseforums[$forumid])) {
1164                 continue;
1165             }
1166             $context = context_module::instance($cm->id);
1167             $forum = $courseforums[$forumid];
1168             $forum->context = $context;
1169             $forum->cm = $cm;
1171             if (!has_capability('mod/forum:viewdiscussion', $context)) {
1172                 continue;
1173             }
1175          /// group access
1176             if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
1178                 $forum->onlygroups = $modinfo->get_groups($cm->groupingid);
1179                 $forum->onlygroups[] = -1;
1180             }
1182         /// hidden timed discussions
1183             $forum->viewhiddentimedposts = true;
1184             if (!empty($CFG->forum_enabletimedposts)) {
1185                 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1186                     $forum->viewhiddentimedposts = false;
1187                 }
1188             }
1190         /// qanda access
1191             if ($forum->type == 'qanda'
1192                     && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
1194                 // We need to check whether the user has posted in the qanda forum.
1195                 $forum->onlydiscussions = array();  // Holds discussion ids for the discussions
1196                                                     // the user is allowed to see in this forum.
1197                 if ($discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $USER->id)) {
1198                     foreach ($discussionspostedin as $d) {
1199                         $forum->onlydiscussions[] = $d->id;
1200                     }
1201                 }
1202             }
1204             $readableforums[$forum->id] = $forum;
1205         }
1207         unset($modinfo);
1209     } // End foreach $courses
1211     return $readableforums;
1214 /**
1215  * Returns a list of posts found using an array of search terms.
1216  *
1217  * @global object
1218  * @global object
1219  * @global object
1220  * @param array $searchterms array of search terms, e.g. word +word -word
1221  * @param int $courseid if 0, we search through the whole site
1222  * @param int $limitfrom
1223  * @param int $limitnum
1224  * @param int &$totalcount
1225  * @param string $extrasql
1226  * @return array|bool Array of posts found or false
1227  */
1228 function forum_search_posts($searchterms, $courseid=0, $limitfrom=0, $limitnum=50,
1229                             &$totalcount, $extrasql='') {
1230     global $CFG, $DB, $USER;
1231     require_once($CFG->libdir.'/searchlib.php');
1233     $forums = forum_get_readable_forums($USER->id, $courseid);
1235     if (count($forums) == 0) {
1236         $totalcount = 0;
1237         return false;
1238     }
1240     $now = floor(time() / 60) * 60; // DB Cache Friendly.
1242     $fullaccess = array();
1243     $where = array();
1244     $params = array();
1246     foreach ($forums as $forumid => $forum) {
1247         $select = array();
1249         if (!$forum->viewhiddentimedposts) {
1250             $select[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
1251             $params = array_merge($params, array('userid'.$forumid=>$USER->id, 'timestart'.$forumid=>$now, 'timeend'.$forumid=>$now));
1252         }
1254         $cm = $forum->cm;
1255         $context = $forum->context;
1257         if ($forum->type == 'qanda'
1258             && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
1259             if (!empty($forum->onlydiscussions)) {
1260                 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forum->onlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
1261                 $params = array_merge($params, $discussionid_params);
1262                 $select[] = "(d.id $discussionid_sql OR p.parent = 0)";
1263             } else {
1264                 $select[] = "p.parent = 0";
1265             }
1266         }
1268         if (!empty($forum->onlygroups)) {
1269             list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($forum->onlygroups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
1270             $params = array_merge($params, $groupid_params);
1271             $select[] = "d.groupid $groupid_sql";
1272         }
1274         if ($select) {
1275             $selects = implode(" AND ", $select);
1276             $where[] = "(d.forum = :forum{$forumid} AND $selects)";
1277             $params['forum'.$forumid] = $forumid;
1278         } else {
1279             $fullaccess[] = $forumid;
1280         }
1281     }
1283     if ($fullaccess) {
1284         list($fullid_sql, $fullid_params) = $DB->get_in_or_equal($fullaccess, SQL_PARAMS_NAMED, 'fula');
1285         $params = array_merge($params, $fullid_params);
1286         $where[] = "(d.forum $fullid_sql)";
1287     }
1289     $selectdiscussion = "(".implode(" OR ", $where).")";
1291     $messagesearch = '';
1292     $searchstring = '';
1294     // Need to concat these back together for parser to work.
1295     foreach($searchterms as $searchterm){
1296         if ($searchstring != '') {
1297             $searchstring .= ' ';
1298         }
1299         $searchstring .= $searchterm;
1300     }
1302     // We need to allow quoted strings for the search. The quotes *should* be stripped
1303     // by the parser, but this should be examined carefully for security implications.
1304     $searchstring = str_replace("\\\"","\"",$searchstring);
1305     $parser = new search_parser();
1306     $lexer = new search_lexer($parser);
1308     if ($lexer->parse($searchstring)) {
1309         $parsearray = $parser->get_parsed_array();
1311         $tagjoins = '';
1312         $tagfields = [];
1313         $tagfieldcount = 0;
1314         foreach ($parsearray as $token) {
1315             if ($token->getType() == TOKEN_TAGS) {
1316                 for ($i = 0; $i <= substr_count($token->getValue(), ','); $i++) {
1317                     // Queries can only have a limited number of joins so set a limit sensible users won't exceed.
1318                     if ($tagfieldcount > 10) {
1319                         continue;
1320                     }
1321                     $tagjoins .= " LEFT JOIN {tag_instance} ti_$tagfieldcount
1322                                         ON p.id = ti_$tagfieldcount.itemid
1323                                             AND ti_$tagfieldcount.component = 'mod_forum'
1324                                             AND ti_$tagfieldcount.itemtype = 'forum_posts'";
1325                     $tagjoins .= " LEFT JOIN {tag} t_$tagfieldcount ON t_$tagfieldcount.id = ti_$tagfieldcount.tagid";
1326                     $tagfields[] = "t_$tagfieldcount.rawname";
1327                     $tagfieldcount++;
1328                 }
1329             }
1330         }
1331         list($messagesearch, $msparams) = search_generate_SQL($parsearray, 'p.message', 'p.subject',
1332                                                               'p.userid', 'u.id', 'u.firstname',
1333                                                               'u.lastname', 'p.modified', 'd.forum',
1334                                                               $tagfields);
1335         $params = array_merge($params, $msparams);
1336     }
1338     $fromsql = "{forum_posts} p
1339                   INNER JOIN {forum_discussions} d ON d.id = p.discussion
1340                   INNER JOIN {user} u ON u.id = p.userid $tagjoins";
1342     $selectsql = " $messagesearch
1343                AND p.discussion = d.id
1344                AND p.userid = u.id
1345                AND $selectdiscussion
1346                    $extrasql";
1348     $countsql = "SELECT COUNT(*)
1349                    FROM $fromsql
1350                   WHERE $selectsql";
1352     $allnames = get_all_user_name_fields(true, 'u');
1353     $searchsql = "SELECT p.*,
1354                          d.forum,
1355                          $allnames,
1356                          u.email,
1357                          u.picture,
1358                          u.imagealt
1359                     FROM $fromsql
1360                    WHERE $selectsql
1361                 ORDER BY p.modified DESC";
1363     $totalcount = $DB->count_records_sql($countsql, $params);
1365     return $DB->get_records_sql($searchsql, $params, $limitfrom, $limitnum);
1368 /**
1369  * Get all the posts for a user in a forum suitable for forum_print_post
1370  *
1371  * @global object
1372  * @global object
1373  * @uses CONTEXT_MODULE
1374  * @return array
1375  */
1376 function forum_get_user_posts($forumid, $userid) {
1377     global $CFG, $DB;
1379     $timedsql = "";
1380     $params = array($forumid, $userid);
1382     if (!empty($CFG->forum_enabletimedposts)) {
1383         $cm = get_coursemodule_from_instance('forum', $forumid);
1384         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
1385             $now = time();
1386             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
1387             $params[] = $now;
1388             $params[] = $now;
1389         }
1390     }
1392     $allnames = get_all_user_name_fields(true, 'u');
1393     return $DB->get_records_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1394                               FROM {forum} f
1395                                    JOIN {forum_discussions} d ON d.forum = f.id
1396                                    JOIN {forum_posts} p       ON p.discussion = d.id
1397                                    JOIN {user} u              ON u.id = p.userid
1398                              WHERE f.id = ?
1399                                    AND p.userid = ?
1400                                    $timedsql
1401                           ORDER BY p.modified ASC", $params);
1404 /**
1405  * Get all the discussions user participated in
1406  *
1407  * @global object
1408  * @global object
1409  * @uses CONTEXT_MODULE
1410  * @param int $forumid
1411  * @param int $userid
1412  * @return array Array or false
1413  */
1414 function forum_get_user_involved_discussions($forumid, $userid) {
1415     global $CFG, $DB;
1417     $timedsql = "";
1418     $params = array($forumid, $userid);
1419     if (!empty($CFG->forum_enabletimedposts)) {
1420         $cm = get_coursemodule_from_instance('forum', $forumid);
1421         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
1422             $now = time();
1423             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
1424             $params[] = $now;
1425             $params[] = $now;
1426         }
1427     }
1429     return $DB->get_records_sql("SELECT DISTINCT d.*
1430                               FROM {forum} f
1431                                    JOIN {forum_discussions} d ON d.forum = f.id
1432                                    JOIN {forum_posts} p       ON p.discussion = d.id
1433                              WHERE f.id = ?
1434                                    AND p.userid = ?
1435                                    $timedsql", $params);
1438 /**
1439  * Get all the posts for a user in a forum suitable for forum_print_post
1440  *
1441  * @global object
1442  * @global object
1443  * @param int $forumid
1444  * @param int $userid
1445  * @return array of counts or false
1446  */
1447 function forum_count_user_posts($forumid, $userid) {
1448     global $CFG, $DB;
1450     $timedsql = "";
1451     $params = array($forumid, $userid);
1452     if (!empty($CFG->forum_enabletimedposts)) {
1453         $cm = get_coursemodule_from_instance('forum', $forumid);
1454         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
1455             $now = time();
1456             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
1457             $params[] = $now;
1458             $params[] = $now;
1459         }
1460     }
1462     return $DB->get_record_sql("SELECT COUNT(p.id) AS postcount, MAX(p.modified) AS lastpost
1463                              FROM {forum} f
1464                                   JOIN {forum_discussions} d ON d.forum = f.id
1465                                   JOIN {forum_posts} p       ON p.discussion = d.id
1466                                   JOIN {user} u              ON u.id = p.userid
1467                             WHERE f.id = ?
1468                                   AND p.userid = ?
1469                                   $timedsql", $params);
1472 /**
1473  * Given a log entry, return the forum post details for it.
1474  *
1475  * @global object
1476  * @global object
1477  * @param object $log
1478  * @return array|null
1479  */
1480 function forum_get_post_from_log($log) {
1481     global $CFG, $DB;
1483     $allnames = get_all_user_name_fields(true, 'u');
1484     if ($log->action == "add post") {
1486         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
1487                                  FROM {forum_discussions} d,
1488                                       {forum_posts} p,
1489                                       {forum} f,
1490                                       {user} u
1491                                 WHERE p.id = ?
1492                                   AND d.id = p.discussion
1493                                   AND p.userid = u.id
1494                                   AND u.deleted <> '1'
1495                                   AND f.id = d.forum", array($log->info));
1498     } else if ($log->action == "add discussion") {
1500         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
1501                                  FROM {forum_discussions} d,
1502                                       {forum_posts} p,
1503                                       {forum} f,
1504                                       {user} u
1505                                 WHERE d.id = ?
1506                                   AND d.firstpost = p.id
1507                                   AND p.userid = u.id
1508                                   AND u.deleted <> '1'
1509                                   AND f.id = d.forum", array($log->info));
1510     }
1511     return NULL;
1514 /**
1515  * Given a discussion id, return the first post from the discussion
1516  *
1517  * @global object
1518  * @global object
1519  * @param int $dicsussionid
1520  * @return array
1521  */
1522 function forum_get_firstpost_from_discussion($discussionid) {
1523     global $CFG, $DB;
1525     return $DB->get_record_sql("SELECT p.*
1526                              FROM {forum_discussions} d,
1527                                   {forum_posts} p
1528                             WHERE d.id = ?
1529                               AND d.firstpost = p.id ", array($discussionid));
1532 /**
1533  * Returns an array of counts of replies to each discussion
1534  *
1535  * @param   int     $forumid
1536  * @param   string  $forumsort
1537  * @param   int     $limit
1538  * @param   int     $page
1539  * @param   int     $perpage
1540  * @param   boolean $canseeprivatereplies   Whether the current user can see private replies.
1541  * @return  array
1542  */
1543 function forum_count_discussion_replies($forumid, $forumsort = "", $limit = -1, $page = -1, $perpage = 0,
1544                                         $canseeprivatereplies = false) {
1545     global $CFG, $DB, $USER;
1547     if ($limit > 0) {
1548         $limitfrom = 0;
1549         $limitnum  = $limit;
1550     } else if ($page != -1) {
1551         $limitfrom = $page*$perpage;
1552         $limitnum  = $perpage;
1553     } else {
1554         $limitfrom = 0;
1555         $limitnum  = 0;
1556     }
1558     if ($forumsort == "") {
1559         $orderby = "";
1560         $groupby = "";
1562     } else {
1563         $orderby = "ORDER BY $forumsort";
1564         $groupby = ", ".strtolower($forumsort);
1565         $groupby = str_replace('desc', '', $groupby);
1566         $groupby = str_replace('asc', '', $groupby);
1567     }
1569     $params = ['forumid' => $forumid];
1571     if (!$canseeprivatereplies) {
1572         $privatewhere = ' AND (p.privatereplyto = :currentuser1 OR p.userid = :currentuser2 OR p.privatereplyto = 0)';
1573         $params['currentuser1'] = $USER->id;
1574         $params['currentuser2'] = $USER->id;
1575     } else {
1576         $privatewhere = '';
1577     }
1579     if (($limitfrom == 0 and $limitnum == 0) or $forumsort == "") {
1580         $sql = "SELECT p.discussion, COUNT(p.id) AS replies, MAX(p.id) AS lastpostid
1581                   FROM {forum_posts} p
1582                        JOIN {forum_discussions} d ON p.discussion = d.id
1583                  WHERE p.parent > 0 AND d.forum = :forumid
1584                        $privatewhere
1585               GROUP BY p.discussion";
1586         return $DB->get_records_sql($sql, $params);
1588     } else {
1589         $sql = "SELECT p.discussion, (COUNT(p.id) - 1) AS replies, MAX(p.id) AS lastpostid
1590                   FROM {forum_posts} p
1591                        JOIN {forum_discussions} d ON p.discussion = d.id
1592                  WHERE d.forum = :forumid
1593                        $privatewhere
1594               GROUP BY p.discussion $groupby $orderby";
1595         return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
1596     }
1599 /**
1600  * @global object
1601  * @global object
1602  * @global object
1603  * @staticvar array $cache
1604  * @param object $forum
1605  * @param object $cm
1606  * @param object $course
1607  * @return mixed
1608  */
1609 function forum_count_discussions($forum, $cm, $course) {
1610     global $CFG, $DB, $USER;
1612     static $cache = array();
1614     $now = floor(time() / 60) * 60; // DB Cache Friendly.
1616     $params = array($course->id);
1618     if (!isset($cache[$course->id])) {
1619         if (!empty($CFG->forum_enabletimedposts)) {
1620             $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
1621             $params[] = $now;
1622             $params[] = $now;
1623         } else {
1624             $timedsql = "";
1625         }
1627         $sql = "SELECT f.id, COUNT(d.id) as dcount
1628                   FROM {forum} f
1629                        JOIN {forum_discussions} d ON d.forum = f.id
1630                  WHERE f.course = ?
1631                        $timedsql
1632               GROUP BY f.id";
1634         if ($counts = $DB->get_records_sql($sql, $params)) {
1635             foreach ($counts as $count) {
1636                 $counts[$count->id] = $count->dcount;
1637             }
1638             $cache[$course->id] = $counts;
1639         } else {
1640             $cache[$course->id] = array();
1641         }
1642     }
1644     if (empty($cache[$course->id][$forum->id])) {
1645         return 0;
1646     }
1648     $groupmode = groups_get_activity_groupmode($cm, $course);
1650     if ($groupmode != SEPARATEGROUPS) {
1651         return $cache[$course->id][$forum->id];
1652     }
1654     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
1655         return $cache[$course->id][$forum->id];
1656     }
1658     require_once($CFG->dirroot.'/course/lib.php');
1660     $modinfo = get_fast_modinfo($course);
1662     $mygroups = $modinfo->get_groups($cm->groupingid);
1664     // add all groups posts
1665     $mygroups[-1] = -1;
1667     list($mygroups_sql, $params) = $DB->get_in_or_equal($mygroups);
1668     $params[] = $forum->id;
1670     if (!empty($CFG->forum_enabletimedposts)) {
1671         $timedsql = "AND d.timestart < $now AND (d.timeend = 0 OR d.timeend > $now)";
1672         $params[] = $now;
1673         $params[] = $now;
1674     } else {
1675         $timedsql = "";
1676     }
1678     $sql = "SELECT COUNT(d.id)
1679               FROM {forum_discussions} d
1680              WHERE d.groupid $mygroups_sql AND d.forum = ?
1681                    $timedsql";
1683     return $DB->get_field_sql($sql, $params);
1686 /**
1687  * Get all discussions in a forum
1688  *
1689  * @global object
1690  * @global object
1691  * @global object
1692  * @uses CONTEXT_MODULE
1693  * @uses VISIBLEGROUPS
1694  * @param object $cm
1695  * @param string $forumsort
1696  * @param bool $fullpost
1697  * @param int $unused
1698  * @param int $limit
1699  * @param bool $userlastmodified
1700  * @param int $page
1701  * @param int $perpage
1702  * @param int $groupid if groups enabled, get discussions for this group overriding the current group.
1703  *                     Use FORUM_POSTS_ALL_USER_GROUPS for all the user groups
1704  * @param int $updatedsince retrieve only discussions updated since the given time
1705  * @return array
1706  */
1707 function forum_get_discussions($cm, $forumsort="", $fullpost=true, $unused=-1, $limit=-1,
1708                                 $userlastmodified=false, $page=-1, $perpage=0, $groupid = -1,
1709                                 $updatedsince = 0) {
1710     global $CFG, $DB, $USER;
1712     $timelimit = '';
1714     $now = floor(time() / 60) * 60;
1715     $params = array($cm->instance);
1717     $modcontext = context_module::instance($cm->id);
1719     if (!has_capability('mod/forum:viewdiscussion', $modcontext)) { /// User must have perms to view discussions
1720         return array();
1721     }
1723     if (!empty($CFG->forum_enabletimedposts)) { /// Users must fulfill timed posts
1725         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
1726             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
1727             $params[] = $now;
1728             $params[] = $now;
1729             if (isloggedin()) {
1730                 $timelimit .= " OR d.userid = ?";
1731                 $params[] = $USER->id;
1732             }
1733             $timelimit .= ")";
1734         }
1735     }
1737     if ($limit > 0) {
1738         $limitfrom = 0;
1739         $limitnum  = $limit;
1740     } else if ($page != -1) {
1741         $limitfrom = $page*$perpage;
1742         $limitnum  = $perpage;
1743     } else {
1744         $limitfrom = 0;
1745         $limitnum  = 0;
1746     }
1748     $groupmode    = groups_get_activity_groupmode($cm);
1750     if ($groupmode) {
1752         if (empty($modcontext)) {
1753             $modcontext = context_module::instance($cm->id);
1754         }
1756         // Special case, we received a groupid to override currentgroup.
1757         if ($groupid > 0) {
1758             $course = get_course($cm->course);
1759             if (!groups_group_visible($groupid, $course, $cm)) {
1760                 // User doesn't belong to this group, return nothing.
1761                 return array();
1762             }
1763             $currentgroup = $groupid;
1764         } else if ($groupid === -1) {
1765             $currentgroup = groups_get_activity_group($cm);
1766         } else {
1767             // Get discussions for all groups current user can see.
1768             $currentgroup = null;
1769         }
1771         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
1772             if ($currentgroup) {
1773                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
1774                 $params[] = $currentgroup;
1775             } else {
1776                 $groupselect = "";
1777             }
1779         } else {
1780             // Separate groups.
1782             // Get discussions for all groups current user can see.
1783             if ($currentgroup === null) {
1784                 $mygroups = array_keys(groups_get_all_groups($cm->course, $USER->id, $cm->groupingid, 'g.id'));
1785                 if (empty($mygroups)) {
1786                      $groupselect = "AND d.groupid = -1";
1787                 } else {
1788                     list($insqlgroups, $inparamsgroups) = $DB->get_in_or_equal($mygroups);
1789                     $groupselect = "AND (d.groupid = -1 OR d.groupid $insqlgroups)";
1790                     $params = array_merge($params, $inparamsgroups);
1791                 }
1792             } else if ($currentgroup) {
1793                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
1794                 $params[] = $currentgroup;
1795             } else {
1796                 $groupselect = "AND d.groupid = -1";
1797             }
1798         }
1799     } else {
1800         $groupselect = "";
1801     }
1802     if (empty($forumsort)) {
1803         $forumsort = forum_get_default_sort_order();
1804     }
1805     if (empty($fullpost)) {
1806         $postdata = "p.id, p.subject, p.modified, p.discussion, p.userid, p.created";
1807     } else {
1808         $postdata = "p.*";
1809     }
1811     if (empty($userlastmodified)) {  // We don't need to know this
1812         $umfields = "";
1813         $umtable  = "";
1814     } else {
1815         $umfields = ', ' . get_all_user_name_fields(true, 'um', null, 'um') . ', um.email AS umemail, um.picture AS umpicture,
1816                         um.imagealt AS umimagealt';
1817         $umtable  = " LEFT JOIN {user} um ON (d.usermodified = um.id)";
1818     }
1820     $updatedsincesql = '';
1821     if (!empty($updatedsince)) {
1822         $updatedsincesql = 'AND d.timemodified > ?';
1823         $params[] = $updatedsince;
1824     }
1826     $discussionfields = "d.id as discussionid, d.course, d.forum, d.name, d.firstpost, d.userid, d.groupid, d.assessed," .
1827     " d.timemodified, d.usermodified, d.timestart, d.timeend, d.pinned, d.locked";
1829     $allnames = get_all_user_name_fields(true, 'u');
1830     $sql = "SELECT $postdata, $discussionfields,
1831                    $allnames, u.email, u.picture, u.imagealt $umfields
1832               FROM {forum_discussions} d
1833                    JOIN {forum_posts} p ON p.discussion = d.id
1834                    JOIN {user} u ON p.userid = u.id
1835                    $umtable
1836              WHERE d.forum = ? AND p.parent = 0
1837                    $timelimit $groupselect $updatedsincesql
1838           ORDER BY $forumsort, d.id DESC";
1840     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
1843 /**
1844  * Gets the neighbours (previous and next) of a discussion.
1845  *
1846  * The calculation is based on the timemodified when time modified or time created is identical
1847  * It will revert to using the ID to sort consistently. This is better tha skipping a discussion.
1848  *
1849  * For blog-style forums, the calculation is based on the original creation time of the
1850  * blog post.
1851  *
1852  * Please note that this does not check whether or not the discussion passed is accessible
1853  * by the user, it simply uses it as a reference to find the neighbours. On the other hand,
1854  * the returned neighbours are checked and are accessible to the current user.
1855  *
1856  * @param object $cm The CM record.
1857  * @param object $discussion The discussion record.
1858  * @param object $forum The forum instance record.
1859  * @return array That always contains the keys 'prev' and 'next'. When there is a result
1860  *               they contain the record with minimal information such as 'id' and 'name'.
1861  *               When the neighbour is not found the value is false.
1862  */
1863 function forum_get_discussion_neighbours($cm, $discussion, $forum) {
1864     global $CFG, $DB, $USER;
1866     if ($cm->instance != $discussion->forum or $discussion->forum != $forum->id or $forum->id != $cm->instance) {
1867         throw new coding_exception('Discussion is not part of the same forum.');
1868     }
1870     $neighbours = array('prev' => false, 'next' => false);
1871     $now = floor(time() / 60) * 60;
1872     $params = array();
1874     $modcontext = context_module::instance($cm->id);
1875     $groupmode    = groups_get_activity_groupmode($cm);
1876     $currentgroup = groups_get_activity_group($cm);
1878     // Users must fulfill timed posts.
1879     $timelimit = '';
1880     if (!empty($CFG->forum_enabletimedposts)) {
1881         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
1882             $timelimit = ' AND ((d.timestart <= :tltimestart AND (d.timeend = 0 OR d.timeend > :tltimeend))';
1883             $params['tltimestart'] = $now;
1884             $params['tltimeend'] = $now;
1885             if (isloggedin()) {
1886                 $timelimit .= ' OR d.userid = :tluserid';
1887                 $params['tluserid'] = $USER->id;
1888             }
1889             $timelimit .= ')';
1890         }
1891     }
1893     // Limiting to posts accessible according to groups.
1894     $groupselect = '';
1895     if ($groupmode) {
1896         if ($groupmode == VISIBLEGROUPS || has_capability('moodle/site:accessallgroups', $modcontext)) {
1897             if ($currentgroup) {
1898                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
1899                 $params['groupid'] = $currentgroup;
1900             }
1901         } else {
1902             if ($currentgroup) {
1903                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
1904                 $params['groupid'] = $currentgroup;
1905             } else {
1906                 $groupselect = 'AND d.groupid = -1';
1907             }
1908         }
1909     }
1911     $params['forumid'] = $cm->instance;
1912     $params['discid1'] = $discussion->id;
1913     $params['discid2'] = $discussion->id;
1914     $params['discid3'] = $discussion->id;
1915     $params['discid4'] = $discussion->id;
1916     $params['disctimecompare1'] = $discussion->timemodified;
1917     $params['disctimecompare2'] = $discussion->timemodified;
1918     $params['pinnedstate1'] = (int) $discussion->pinned;
1919     $params['pinnedstate2'] = (int) $discussion->pinned;
1920     $params['pinnedstate3'] = (int) $discussion->pinned;
1921     $params['pinnedstate4'] = (int) $discussion->pinned;
1923     $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
1924               FROM {forum_discussions} d
1925               JOIN {forum_posts} p ON d.firstpost = p.id
1926              WHERE d.forum = :forumid
1927                AND d.id <> :discid1
1928                    $timelimit
1929                    $groupselect";
1930     $comparefield = "d.timemodified";
1931     $comparevalue = ":disctimecompare1";
1932     $comparevalue2  = ":disctimecompare2";
1933     if (!empty($CFG->forum_enabletimedposts)) {
1934         // Here we need to take into account the release time (timestart)
1935         // if one is set, of the neighbouring posts and compare it to the
1936         // timestart or timemodified of *this* post depending on if the
1937         // release date of this post is in the future or not.
1938         // This stops discussions that appear later because of the
1939         // timestart value from being buried under discussions that were
1940         // made afterwards.
1941         $comparefield = "CASE WHEN d.timemodified < d.timestart
1942                                 THEN d.timestart ELSE d.timemodified END";
1943         if ($discussion->timemodified < $discussion->timestart) {
1944             // Normally we would just use the timemodified for sorting
1945             // discussion posts. However, when timed discussions are enabled,
1946             // then posts need to be sorted base on the later of timemodified
1947             // or the release date of the post (timestart).
1948             $params['disctimecompare1'] = $discussion->timestart;
1949             $params['disctimecompare2'] = $discussion->timestart;
1950         }
1951     }
1952     $orderbydesc = forum_get_default_sort_order(true, $comparefield, 'd', false);
1953     $orderbyasc = forum_get_default_sort_order(false, $comparefield, 'd', false);
1955     if ($forum->type === 'blog') {
1956          $subselect = "SELECT pp.created
1957                    FROM {forum_discussions} dd
1958                    JOIN {forum_posts} pp ON dd.firstpost = pp.id ";
1960          $subselectwhere1 = " WHERE dd.id = :discid3";
1961          $subselectwhere2 = " WHERE dd.id = :discid4";
1963          $comparefield = "p.created";
1965          $sub1 = $subselect.$subselectwhere1;
1966          $comparevalue = "($sub1)";
1968          $sub2 = $subselect.$subselectwhere2;
1969          $comparevalue2 = "($sub2)";
1971          $orderbydesc = "d.pinned, p.created DESC";
1972          $orderbyasc = "d.pinned, p.created ASC";
1973     }
1975     $prevsql = $sql . " AND ( (($comparefield < $comparevalue) AND :pinnedstate1 = d.pinned)
1976                          OR ($comparefield = $comparevalue2 AND (d.pinned = 0 OR d.pinned = :pinnedstate4) AND d.id < :discid2)
1977                          OR (d.pinned = 0 AND d.pinned <> :pinnedstate2))
1978                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbydesc, d.id DESC";
1980     $nextsql = $sql . " AND ( (($comparefield > $comparevalue) AND :pinnedstate1 = d.pinned)
1981                          OR ($comparefield = $comparevalue2 AND (d.pinned = 1 OR d.pinned = :pinnedstate4) AND d.id > :discid2)
1982                          OR (d.pinned = 1 AND d.pinned <> :pinnedstate2))
1983                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbyasc, d.id ASC";
1985     $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
1986     $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
1987     return $neighbours;
1990 /**
1991  * Get the sql to use in the ORDER BY clause for forum discussions.
1992  *
1993  * This has the ordering take timed discussion windows into account.
1994  *
1995  * @param bool $desc True for DESC, False for ASC.
1996  * @param string $compare The field in the SQL to compare to normally sort by.
1997  * @param string $prefix The prefix being used for the discussion table.
1998  * @param bool $pinned sort pinned posts to the top
1999  * @return string
2000  */
2001 function forum_get_default_sort_order($desc = true, $compare = 'd.timemodified', $prefix = 'd', $pinned = true) {
2002     global $CFG;
2004     if (!empty($prefix)) {
2005         $prefix .= '.';
2006     }
2008     $dir = $desc ? 'DESC' : 'ASC';
2010     if ($pinned == true) {
2011         $pinned = "{$prefix}pinned DESC,";
2012     } else {
2013         $pinned = '';
2014     }
2016     $sort = "{$prefix}timemodified";
2017     if (!empty($CFG->forum_enabletimedposts)) {
2018         $sort = "CASE WHEN {$compare} < {$prefix}timestart
2019                  THEN {$prefix}timestart
2020                  ELSE {$compare}
2021                  END";
2022     }
2023     return "$pinned $sort $dir";
2026 /**
2027  *
2028  * @global object
2029  * @global object
2030  * @global object
2031  * @uses CONTEXT_MODULE
2032  * @uses VISIBLEGROUPS
2033  * @param object $cm
2034  * @return array
2035  */
2036 function forum_get_discussions_unread($cm) {
2037     global $CFG, $DB, $USER;
2039     $now = floor(time() / 60) * 60;
2040     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2042     $params = array();
2043     $groupmode    = groups_get_activity_groupmode($cm);
2044     $currentgroup = groups_get_activity_group($cm);
2046     if ($groupmode) {
2047         $modcontext = context_module::instance($cm->id);
2049         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2050             if ($currentgroup) {
2051                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2052                 $params['currentgroup'] = $currentgroup;
2053             } else {
2054                 $groupselect = "";
2055             }
2057         } else {
2058             //separate groups without access all
2059             if ($currentgroup) {
2060                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2061                 $params['currentgroup'] = $currentgroup;
2062             } else {
2063                 $groupselect = "AND d.groupid = -1";
2064             }
2065         }
2066     } else {
2067         $groupselect = "";
2068     }
2070     if (!empty($CFG->forum_enabletimedposts)) {
2071         $timedsql = "AND d.timestart < :now1 AND (d.timeend = 0 OR d.timeend > :now2)";
2072         $params['now1'] = $now;
2073         $params['now2'] = $now;
2074     } else {
2075         $timedsql = "";
2076     }
2078     $sql = "SELECT d.id, COUNT(p.id) AS unread
2079               FROM {forum_discussions} d
2080                    JOIN {forum_posts} p     ON p.discussion = d.id
2081                    LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = $USER->id)
2082              WHERE d.forum = {$cm->instance}
2083                    AND p.modified >= :cutoffdate AND r.id is NULL
2084                    $groupselect
2085                    $timedsql
2086           GROUP BY d.id";
2087     $params['cutoffdate'] = $cutoffdate;
2089     if ($unreads = $DB->get_records_sql($sql, $params)) {
2090         foreach ($unreads as $unread) {
2091             $unreads[$unread->id] = $unread->unread;
2092         }
2093         return $unreads;
2094     } else {
2095         return array();
2096     }
2099 /**
2100  * @global object
2101  * @global object
2102  * @global object
2103  * @uses CONEXT_MODULE
2104  * @uses VISIBLEGROUPS
2105  * @param object $cm
2106  * @return array
2107  */
2108 function forum_get_discussions_count($cm) {
2109     global $CFG, $DB, $USER;
2111     $now = floor(time() / 60) * 60;
2112     $params = array($cm->instance);
2113     $groupmode    = groups_get_activity_groupmode($cm);
2114     $currentgroup = groups_get_activity_group($cm);
2116     if ($groupmode) {
2117         $modcontext = context_module::instance($cm->id);
2119         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2120             if ($currentgroup) {
2121                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2122                 $params[] = $currentgroup;
2123             } else {
2124                 $groupselect = "";
2125             }
2127         } else {
2128             //seprate groups without access all
2129             if ($currentgroup) {
2130                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2131                 $params[] = $currentgroup;
2132             } else {
2133                 $groupselect = "AND d.groupid = -1";
2134             }
2135         }
2136     } else {
2137         $groupselect = "";
2138     }
2140     $timelimit = "";
2142     if (!empty($CFG->forum_enabletimedposts)) {
2144         $modcontext = context_module::instance($cm->id);
2146         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2147             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2148             $params[] = $now;
2149             $params[] = $now;
2150             if (isloggedin()) {
2151                 $timelimit .= " OR d.userid = ?";
2152                 $params[] = $USER->id;
2153             }
2154             $timelimit .= ")";
2155         }
2156     }
2158     $sql = "SELECT COUNT(d.id)
2159               FROM {forum_discussions} d
2160                    JOIN {forum_posts} p ON p.discussion = d.id
2161              WHERE d.forum = ? AND p.parent = 0
2162                    $groupselect $timelimit";
2164     return $DB->get_field_sql($sql, $params);
2168 // OTHER FUNCTIONS ///////////////////////////////////////////////////////////
2171 /**
2172  * @global object
2173  * @global object
2174  * @param int $courseid
2175  * @param string $type
2176  */
2177 function forum_get_course_forum($courseid, $type) {
2178 // How to set up special 1-per-course forums
2179     global $CFG, $DB, $OUTPUT, $USER;
2181     if ($forums = $DB->get_records_select("forum", "course = ? AND type = ?", array($courseid, $type), "id ASC")) {
2182         // There should always only be ONE, but with the right combination of
2183         // errors there might be more.  In this case, just return the oldest one (lowest ID).
2184         foreach ($forums as $forum) {
2185             return $forum;   // ie the first one
2186         }
2187     }
2189     // Doesn't exist, so create one now.
2190     $forum = new stdClass();
2191     $forum->course = $courseid;
2192     $forum->type = "$type";
2193     if (!empty($USER->htmleditor)) {
2194         $forum->introformat = $USER->htmleditor;
2195     }
2196     switch ($forum->type) {
2197         case "news":
2198             $forum->name  = get_string("namenews", "forum");
2199             $forum->intro = get_string("intronews", "forum");
2200             $forum->introformat = FORMAT_HTML;
2201             $forum->forcesubscribe = FORUM_FORCESUBSCRIBE;
2202             $forum->assessed = 0;
2203             if ($courseid == SITEID) {
2204                 $forum->name  = get_string("sitenews");
2205                 $forum->forcesubscribe = 0;
2206             }
2207             break;
2208         case "social":
2209             $forum->name  = get_string("namesocial", "forum");
2210             $forum->intro = get_string("introsocial", "forum");
2211             $forum->introformat = FORMAT_HTML;
2212             $forum->assessed = 0;
2213             $forum->forcesubscribe = 0;
2214             break;
2215         case "blog":
2216             $forum->name = get_string('blogforum', 'forum');
2217             $forum->intro = get_string('introblog', 'forum');
2218             $forum->introformat = FORMAT_HTML;
2219             $forum->assessed = 0;
2220             $forum->forcesubscribe = 0;
2221             break;
2222         default:
2223             echo $OUTPUT->notification("That forum type doesn't exist!");
2224             return false;
2225             break;
2226     }
2228     $forum->timemodified = time();
2229     $forum->id = $DB->insert_record("forum", $forum);
2231     if (! $module = $DB->get_record("modules", array("name" => "forum"))) {
2232         echo $OUTPUT->notification("Could not find forum module!!");
2233         return false;
2234     }
2235     $mod = new stdClass();
2236     $mod->course = $courseid;
2237     $mod->module = $module->id;
2238     $mod->instance = $forum->id;
2239     $mod->section = 0;
2240     include_once("$CFG->dirroot/course/lib.php");
2241     if (! $mod->coursemodule = add_course_module($mod) ) {
2242         echo $OUTPUT->notification("Could not add a new course module to the course '" . $courseid . "'");
2243         return false;
2244     }
2245     $sectionid = course_add_cm_to_section($courseid, $mod->coursemodule, 0);
2246     return $DB->get_record("forum", array("id" => "$forum->id"));
2249 /**
2250  * Return rating related permissions
2251  *
2252  * @param string $options the context id
2253  * @return array an associative array of the user's rating permissions
2254  */
2255 function forum_rating_permissions($contextid, $component, $ratingarea) {
2256     $context = context::instance_by_id($contextid, MUST_EXIST);
2257     if ($component != 'mod_forum' || $ratingarea != 'post') {
2258         // We don't know about this component/ratingarea so just return null to get the
2259         // default restrictive permissions.
2260         return null;
2261     }
2262     return array(
2263         'view'    => has_capability('mod/forum:viewrating', $context),
2264         'viewany' => has_capability('mod/forum:viewanyrating', $context),
2265         'viewall' => has_capability('mod/forum:viewallratings', $context),
2266         'rate'    => has_capability('mod/forum:rate', $context)
2267     );
2270 /**
2271  * Validates a submitted rating
2272  * @param array $params submitted data
2273  *            context => object the context in which the rated items exists [required]
2274  *            component => The component for this module - should always be mod_forum [required]
2275  *            ratingarea => object the context in which the rated items exists [required]
2276  *
2277  *            itemid => int the ID of the object being rated [required]
2278  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
2279  *            rating => int the submitted rating [required]
2280  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
2281  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
2282  * @return boolean true if the rating is valid. Will throw rating_exception if not
2283  */
2284 function forum_rating_validate($params) {
2285     global $DB, $USER;
2287     // Check the component is mod_forum
2288     if ($params['component'] != 'mod_forum') {
2289         throw new rating_exception('invalidcomponent');
2290     }
2292     // Check the ratingarea is post (the only rating area in forum)
2293     if ($params['ratingarea'] != 'post') {
2294         throw new rating_exception('invalidratingarea');
2295     }
2297     // Check the rateduserid is not the current user .. you can't rate your own posts
2298     if ($params['rateduserid'] == $USER->id) {
2299         throw new rating_exception('nopermissiontorate');
2300     }
2302     // Fetch all the related records ... we need to do this anyway to call forum_user_can_see_post
2303     $post = $DB->get_record('forum_posts', array('id' => $params['itemid'], 'userid' => $params['rateduserid']), '*', MUST_EXIST);
2304     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion), '*', MUST_EXIST);
2305     $forum = $DB->get_record('forum', array('id' => $discussion->forum), '*', MUST_EXIST);
2306     $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
2307     $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id , false, MUST_EXIST);
2308     $context = context_module::instance($cm->id);
2310     // Make sure the context provided is the context of the forum
2311     if ($context->id != $params['context']->id) {
2312         throw new rating_exception('invalidcontext');
2313     }
2315     if ($forum->scale != $params['scaleid']) {
2316         //the scale being submitted doesnt match the one in the database
2317         throw new rating_exception('invalidscaleid');
2318     }
2320     // check the item we're rating was created in the assessable time window
2321     if (!empty($forum->assesstimestart) && !empty($forum->assesstimefinish)) {
2322         if ($post->created < $forum->assesstimestart || $post->created > $forum->assesstimefinish) {
2323             throw new rating_exception('notavailable');
2324         }
2325     }
2327     //check that the submitted rating is valid for the scale
2329     // lower limit
2330     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
2331         throw new rating_exception('invalidnum');
2332     }
2334     // upper limit
2335     if ($forum->scale < 0) {
2336         //its a custom scale
2337         $scalerecord = $DB->get_record('scale', array('id' => -$forum->scale));
2338         if ($scalerecord) {
2339             $scalearray = explode(',', $scalerecord->scale);
2340             if ($params['rating'] > count($scalearray)) {
2341                 throw new rating_exception('invalidnum');
2342             }
2343         } else {
2344             throw new rating_exception('invalidscaleid');
2345         }
2346     } else if ($params['rating'] > $forum->scale) {
2347         //if its numeric and submitted rating is above maximum
2348         throw new rating_exception('invalidnum');
2349     }
2351     // Make sure groups allow this user to see the item they're rating
2352     if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
2353         if (!groups_group_exists($discussion->groupid)) { // Can't find group
2354             throw new rating_exception('cannotfindgroup');//something is wrong
2355         }
2357         if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
2358             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
2359             throw new rating_exception('notmemberofgroup');
2360         }
2361     }
2363     // perform some final capability checks
2364     if (!forum_user_can_see_post($forum, $discussion, $post, $USER, $cm)) {
2365         throw new rating_exception('nopermissiontorate');
2366     }
2368     return true;
2371 /**
2372  * Can the current user see ratings for a given itemid?
2373  *
2374  * @param array $params submitted data
2375  *            contextid => int contextid [required]
2376  *            component => The component for this module - should always be mod_forum [required]
2377  *            ratingarea => object the context in which the rated items exists [required]
2378  *            itemid => int the ID of the object being rated [required]
2379  *            scaleid => int scale id [optional]
2380  * @return bool
2381  * @throws coding_exception
2382  * @throws rating_exception
2383  */
2384 function mod_forum_rating_can_see_item_ratings($params) {
2385     global $DB, $USER;
2387     // Check the component is mod_forum.
2388     if (!isset($params['component']) || $params['component'] != 'mod_forum') {
2389         throw new rating_exception('invalidcomponent');
2390     }
2392     // Check the ratingarea is post (the only rating area in forum).
2393     if (!isset($params['ratingarea']) || $params['ratingarea'] != 'post') {
2394         throw new rating_exception('invalidratingarea');
2395     }
2397     if (!isset($params['itemid'])) {
2398         throw new rating_exception('invaliditemid');
2399     }
2401     $post = $DB->get_record('forum_posts', array('id' => $params['itemid']), '*', MUST_EXIST);
2402     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion), '*', MUST_EXIST);
2403     $forum = $DB->get_record('forum', array('id' => $discussion->forum), '*', MUST_EXIST);
2404     $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
2405     $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id , false, MUST_EXIST);
2407     // Perform some final capability checks.
2408     if (!forum_user_can_see_post($forum, $discussion, $post, $USER, $cm)) {
2409         return false;
2410     }
2412     return true;
2415 /**
2416  * This function prints the overview of a discussion in the forum listing.
2417  * It needs some discussion information and some post information, these
2418  * happen to be combined for efficiency in the $post parameter by the function
2419  * that calls this one: forum_print_latest_discussions()
2420  *
2421  * @global object
2422  * @global object
2423  * @param object $post The post object (passed by reference for speed).
2424  * @param object $forum The forum object.
2425  * @param int $group Current group.
2426  * @param string $datestring Format to use for the dates.
2427  * @param boolean $cantrack Is tracking enabled for this forum.
2428  * @param boolean $forumtracked Is the user tracking this forum.
2429  * @param boolean $canviewparticipants True if user has the viewparticipants permission for this course
2430  * @param boolean $canviewhiddentimedposts True if user has the viewhiddentimedposts permission for this forum
2431  */
2432 function forum_print_discussion_header(&$post, $forum, $group = -1, $datestring = "",
2433                                         $cantrack = true, $forumtracked = true, $canviewparticipants = true, $modcontext = null,
2434                                         $canviewhiddentimedposts = false) {
2436     global $COURSE, $USER, $CFG, $OUTPUT, $PAGE;
2438     static $rowcount;
2439     static $strmarkalldread;
2441     if (empty($modcontext)) {
2442         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
2443             print_error('invalidcoursemodule');
2444         }
2445         $modcontext = context_module::instance($cm->id);
2446     }
2448     if (!isset($rowcount)) {
2449         $rowcount = 0;
2450         $strmarkalldread = get_string('markalldread', 'forum');
2451     } else {
2452         $rowcount = ($rowcount + 1) % 2;
2453     }
2455     $post->subject = format_string($post->subject,true);
2457     $canviewfullnames = has_capability('moodle/site:viewfullnames', $modcontext);
2458     $timeddiscussion = !empty($CFG->forum_enabletimedposts) && ($post->timestart || $post->timeend);
2459     $timedoutsidewindow = '';
2460     if ($timeddiscussion && ($post->timestart > time() || ($post->timeend != 0 && $post->timeend < time()))) {
2461         $timedoutsidewindow = ' dimmed_text';
2462     }
2464     echo "\n\n";
2465     echo '<tr class="discussion r'.$rowcount.$timedoutsidewindow.'">';
2467     $topicclass = 'topic starter';
2468     if (FORUM_DISCUSSION_PINNED == $post->pinned) {
2469         $topicclass .= ' pinned';
2470     }
2471     echo '<td class="'.$topicclass.'">';
2472     if (FORUM_DISCUSSION_PINNED == $post->pinned) {
2473         echo $OUTPUT->pix_icon('i/pinned', get_string('discussionpinned', 'forum'), 'mod_forum');
2474     }
2475     $canalwaysseetimedpost = $USER->id == $post->userid || $canviewhiddentimedposts;
2476     if ($timeddiscussion && $canalwaysseetimedpost) {
2477         echo $PAGE->get_renderer('mod_forum')->timed_discussion_tooltip($post, empty($timedoutsidewindow));
2478     }
2480     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">'.$post->subject.'</a>';
2481     echo "</td>\n";
2483     // Picture
2484     $postuser = new stdClass();
2485     $postuserfields = explode(',', user_picture::fields());
2486     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
2487     $postuser->id = $post->userid;
2488     echo '<td class="author">';
2489     echo '<div class="media">';
2490     echo '<span class="float-left">';
2491     echo $OUTPUT->user_picture($postuser, array('courseid'=>$forum->course));
2492     echo '</span>';
2493     // User name
2494     echo '<div class="media-body">';
2495     $fullname = fullname($postuser, $canviewfullnames);
2496     echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->userid.'&amp;course='.$forum->course.'">'.$fullname.'</a>';
2497     echo '</div>';
2498     echo '</div>';
2499     echo "</td>\n";
2501     // Group picture
2502     if ($group !== -1) {  // Groups are active - group is a group data object or NULL
2503         echo '<td class="picture group">';
2504         if (!empty($group->picture) and empty($group->hidepicture)) {
2505             if ($canviewparticipants && $COURSE->groupmode) {
2506                 $picturelink = true;
2507             } else {
2508                 $picturelink = false;
2509             }
2510             print_group_picture($group, $forum->course, false, false, $picturelink);
2511         } else if (isset($group->id)) {
2512             if ($canviewparticipants && $COURSE->groupmode) {
2513                 echo '<a href="'.$CFG->wwwroot.'/user/index.php?id='.$forum->course.'&amp;group='.$group->id.'">'.$group->name.'</a>';
2514             } else {
2515                 echo $group->name;
2516             }
2517         }
2518         echo "</td>\n";
2519     }
2521     if (has_capability('mod/forum:viewdiscussion', $modcontext)) {   // Show the column with replies
2522         echo '<td class="replies">';
2523         echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
2524         echo $post->replies.'</a>';
2525         echo "</td>\n";
2527         if ($cantrack) {
2528             echo '<td class="replies">';
2529             if ($forumtracked) {
2530                 if ($post->unread > 0) {
2531                     echo '<span class="unread">';
2532                     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'#unread">';
2533                     echo $post->unread;
2534                     echo '</a>';
2535                     echo '<a title="'.$strmarkalldread.'" href="'.$CFG->wwwroot.'/mod/forum/markposts.php?f='.
2536                          $forum->id.'&amp;d='.$post->discussion.'&amp;mark=read&amp;return=/mod/forum/view.php&amp;sesskey=' .
2537                          sesskey() . '">' . $OUTPUT->pix_icon('t/markasread', $strmarkalldread) . '</a>';
2538                     echo '</span>';
2539                 } else {
2540                     echo '<span class="read">';
2541                     echo $post->unread;
2542                     echo '</span>';
2543                 }
2544             } else {
2545                 echo '<span class="read">';
2546                 echo '-';
2547                 echo '</span>';
2548             }
2549             echo "</td>\n";
2550         }
2551     }
2553     echo '<td class="lastpost">';
2554     $usedate = (empty($post->timemodified)) ? $post->created : $post->timemodified;
2555     $parenturl = '';
2556     $usermodified = new stdClass();
2557     $usermodified->id = $post->usermodified;
2558     $usermodified = username_load_fields_from_object($usermodified, $post, 'um');
2560     // In QA forums we check that the user can view participants.
2561     if ($forum->type !== 'qanda' || $canviewparticipants) {
2562         echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->usermodified.'&amp;course='.$forum->course.'">'.
2563              fullname($usermodified, $canviewfullnames).'</a><br />';
2564         $parenturl = (empty($post->lastpostid)) ? '' : '&amp;parent='.$post->lastpostid;
2565     }
2567     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.$parenturl.'">'.
2568           userdate_htmltime($usedate, $datestring).'</a>';
2569     echo "</td>\n";
2571     // is_guest should be used here as this also checks whether the user is a guest in the current course.
2572     // Guests and visitors cannot subscribe - only enrolled users.
2573     if ((!is_guest($modcontext, $USER) && isloggedin()) && has_capability('mod/forum:viewdiscussion', $modcontext)) {
2574         // Discussion subscription.
2575         if (\mod_forum\subscriptions::is_subscribable($forum)) {
2576             echo '<td class="discussionsubscription">';
2577             echo forum_get_discussion_subscription_icon($forum, $post->discussion);
2578             echo '</td>';
2579         }
2580     }
2582     echo "</tr>\n\n";
2586 /**
2587  * Return the markup for the discussion lock toggling icon.
2588  * @param stdClass $forum forum record
2589  * @param stdClass $discussion discussion record
2590  * @param null $returnurl the return url to use
2591  * @param bool $includetext Whether or not to include the text with the icon
2592  * @return string
2593  * @throws coding_exception
2594  * @throws moodle_exception
2595  */
2596 function forum_get_lock_discussion_icon($forum, $discussion, $returnurl = null, $includetext = false) {
2597     global $USER, $OUTPUT, $PAGE;
2599     if ($returnurl === null && $PAGE->url) {
2600         $returnurl = $PAGE->url->out();
2601     }
2603     $discussionid = $discussion->id;
2604     $lockstatus = forum_discussion_is_locked($forum, $discussion);
2605     $subscriptionlink = new moodle_url('/mod/forum/lockdiscussion.php', array(
2606         'sesskey' => sesskey(),
2607         'id' => $forum->id,
2608         'd' => $discussion->id,
2609         'returnurl' => $returnurl,
2610     ));
2612     if ($lockstatus) {
2613         $output = $OUTPUT->pix_icon('t/unlock', get_string('clicktounlockdiscussion', 'forum'), 'core');
2614         if ($includetext) {
2615             $output .= get_string('locked', 'mod_forum');
2616         }
2618         return html_writer::link($subscriptionlink, $output, array(
2619             'title' => get_string('clicktounlockdiscussion', 'forum'),
2620             'class' => 'iconsmall',
2621             'data-forumid' => $forum->id,
2622             'data-discussionid' => $discussionid,
2623             'data-action' => 'toggle',
2624             'data-type' => 'lock-toggle',
2625             'data-state' => $discussion->locked
2626         ));
2628     } else {
2629         $output = $OUTPUT->pix_icon('t/lock', get_string('clicktolockdiscussion', 'forum'), 'core');
2630         if ($includetext) {
2631             $output .= get_string('notlocked', 'mod_forum');
2632         }
2634         return html_writer::link("#", $output, array(
2635             'title' => get_string('clicktolockdiscussion', 'forum'),
2636             'class' => 'iconsmall',
2637             'data-forumid' => $forum->id,
2638             'data-discussionid' => $discussionid,
2639             'data-action' => 'toggle',
2640             'data-type' => 'lock-toggle',
2641             'data-state' => $discussion->locked
2642         ));
2643     }
2646 /**
2647  * Return the markup for the discussion subscription toggling icon.
2648  *
2649  * @param stdClass $forum The forum object.
2650  * @param int $discussionid The discussion to create an icon for.
2651  * @return string The generated markup.
2652  */
2653 function forum_get_discussion_subscription_icon($forum, $discussionid, $returnurl = null, $includetext = false) {
2654     global $USER, $OUTPUT, $PAGE;
2656     if ($returnurl === null && $PAGE->url) {
2657         $returnurl = $PAGE->url->out();
2658     }
2660     $o = '';
2661     $subscriptionstatus = \mod_forum\subscriptions::is_subscribed($USER->id, $forum, $discussionid);
2662     $subscriptionlink = new moodle_url('/mod/forum/subscribe.php', array(
2663         'sesskey' => sesskey(),
2664         'id' => $forum->id,
2665         'd' => $discussionid,
2666         'returnurl' => $returnurl,
2667     ));
2669     if ($includetext) {
2670         $o .= $subscriptionstatus ? get_string('subscribed', 'mod_forum') : get_string('notsubscribed', 'mod_forum');
2671     }
2673     if ($subscriptionstatus) {
2674         $output = $OUTPUT->pix_icon('t/subscribed', get_string('clicktounsubscribe', 'forum'), 'mod_forum');
2675         if ($includetext) {
2676             $output .= get_string('subscribed', 'mod_forum');
2677         }
2679         return html_writer::link($subscriptionlink, $output, array(
2680                 'title' => get_string('clicktounsubscribe', 'forum'),
2681                 'class' => 'discussiontoggle iconsmall',
2682                 'data-forumid' => $forum->id,
2683                 'data-discussionid' => $discussionid,
2684                 'data-includetext' => $includetext,
2685             ));
2687     } else {
2688         $output = $OUTPUT->pix_icon('t/unsubscribed', get_string('clicktosubscribe', 'forum'), 'mod_forum');
2689         if ($includetext) {
2690             $output .= get_string('notsubscribed', 'mod_forum');
2691         }
2693         return html_writer::link($subscriptionlink, $output, array(
2694                 'title' => get_string('clicktosubscribe', 'forum'),
2695                 'class' => 'discussiontoggle iconsmall',
2696                 'data-forumid' => $forum->id,
2697                 'data-discussionid' => $discussionid,
2698                 'data-includetext' => $includetext,
2699             ));
2700     }
2703 /**
2704  * Return a pair of spans containing classes to allow the subscribe and
2705  * unsubscribe icons to be pre-loaded by a browser.
2706  *
2707  * @return string The generated markup
2708  */
2709 function forum_get_discussion_subscription_icon_preloaders() {
2710     $o = '';
2711     $o .= html_writer::span('&nbsp;', 'preload-subscribe');
2712     $o .= html_writer::span('&nbsp;', 'preload-unsubscribe');
2713     return $o;
2716 /**
2717  * Print the drop down that allows the user to select how they want to have
2718  * the discussion displayed.
2719  *
2720  * @param int $id forum id if $forumtype is 'single',
2721  *              discussion id for any other forum type
2722  * @param mixed $mode forum layout mode
2723  * @param string $forumtype optional
2724  */
2725 function forum_print_mode_form($id, $mode, $forumtype='') {
2726     global $OUTPUT;
2727     if ($forumtype == 'single') {
2728         $select = new single_select(new moodle_url("/mod/forum/view.php", array('f'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
2729         $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
2730         $select->class = "forummode";
2731     } else {
2732         $select = new single_select(new moodle_url("/mod/forum/discuss.php", array('d'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
2733         $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
2734     }
2735     echo $OUTPUT->render($select);
2738 /**
2739  * @global object
2740  * @param object $course
2741  * @param string $search
2742  * @return string
2743  */
2744 function forum_search_form($course, $search='') {
2745     global $CFG, $PAGE;
2746     $forumsearch = new \mod_forum\output\quick_search_form($course->id, $search);
2747     $output = $PAGE->get_renderer('mod_forum');
2748     return $output->render($forumsearch);
2752 /**
2753  * @global object
2754  * @global object
2755  */
2756 function forum_set_return() {
2757     global $CFG, $SESSION;
2759     if (! isset($SESSION->fromdiscussion)) {
2760         $referer = get_local_referer(false);
2761         // If the referer is NOT a login screen then save it.
2762         if (! strncasecmp("$CFG->wwwroot/login", $referer, 300)) {
2763             $SESSION->fromdiscussion = $referer;
2764         }
2765     }
2769 /**
2770  * @global object
2771  * @param string|\moodle_url $default
2772  * @return string
2773  */
2774 function forum_go_back_to($default) {
2775     global $SESSION;
2777     if (!empty($SESSION->fromdiscussion)) {
2778         $returnto = $SESSION->fromdiscussion;
2779         unset($SESSION->fromdiscussion);
2780         return $returnto;
2781     } else {
2782         return $default;
2783     }
2786 /**
2787  * Given a discussion object that is being moved to $forumto,
2788  * this function checks all posts in that discussion
2789  * for attachments, and if any are found, these are
2790  * moved to the new forum directory.
2791  *
2792  * @global object
2793  * @param object $discussion
2794  * @param int $forumfrom source forum id
2795  * @param int $forumto target forum id
2796  * @return bool success
2797  */
2798 function forum_move_attachments($discussion, $forumfrom, $forumto) {
2799     global $DB;
2801     $fs = get_file_storage();
2803     $newcm = get_coursemodule_from_instance('forum', $forumto);
2804     $oldcm = get_coursemodule_from_instance('forum', $forumfrom);
2806     $newcontext = context_module::instance($newcm->id);
2807     $oldcontext = context_module::instance($oldcm->id);
2809     // loop through all posts, better not use attachment flag ;-)
2810     if ($posts = $DB->get_records('forum_posts', array('discussion'=>$discussion->id), '', 'id, attachment')) {
2811         foreach ($posts as $post) {
2812             $fs->move_area_files_to_new_context($oldcontext->id,
2813                     $newcontext->id, 'mod_forum', 'post', $post->id);
2814             $attachmentsmoved = $fs->move_area_files_to_new_context($oldcontext->id,
2815                     $newcontext->id, 'mod_forum', 'attachment', $post->id);
2816             if ($attachmentsmoved > 0 && $post->attachment != '1') {
2817                 // Weird - let's fix it
2818                 $post->attachment = '1';
2819                 $DB->update_record('forum_posts', $post);
2820             } else if ($attachmentsmoved == 0 && $post->attachment != '') {
2821                 // Weird - let's fix it
2822                 $post->attachment = '';
2823                 $DB->update_record('forum_posts', $post);
2824             }
2825         }
2826     }
2828     return true;
2831 /**
2832  * Returns attachments as formated text/html optionally with separate images
2833  *
2834  * @global object
2835  * @global object
2836  * @global object
2837  * @param object $post
2838  * @param object $cm
2839  * @param string $type html/text/separateimages
2840  * @return mixed string or array of (html text withouth images and image HTML)
2841  */
2842 function forum_print_attachments($post, $cm, $type) {
2843     global $CFG, $DB, $USER, $OUTPUT;
2845     if (empty($post->attachment)) {
2846         return $type !== 'separateimages' ? '' : array('', '');
2847     }
2849     if (!in_array($type, array('separateimages', 'html', 'text'))) {
2850         return $type !== 'separateimages' ? '' : array('', '');
2851     }
2853     if (!$context = context_module::instance($cm->id)) {
2854         return $type !== 'separateimages' ? '' : array('', '');
2855     }
2856     $strattachment = get_string('attachment', 'forum');
2858     $fs = get_file_storage();
2860     $imagereturn = '';
2861     $output = '';
2863     $canexport = !empty($CFG->enableportfolios) && (has_capability('mod/forum:exportpost', $context) || ($post->userid == $USER->id && has_capability('mod/forum:exportownpost', $context)));
2865     if ($canexport) {
2866         require_once($CFG->libdir.'/portfoliolib.php');
2867     }
2869     // We retrieve all files according to the time that they were created.  In the case that several files were uploaded
2870     // at the sametime (e.g. in the case of drag/drop upload) we revert to using the filename.
2871     $files = $fs->get_area_files($context->id, 'mod_forum', 'attachment', $post->id, "filename", false);
2872     if ($files) {
2873         if ($canexport) {
2874             $button = new portfolio_add_button();
2875         }
2876         foreach ($files as $file) {
2877             $filename = $file->get_filename();
2878             $mimetype = $file->get_mimetype();
2879             $iconimage = $OUTPUT->pix_icon(file_file_icon($file), get_mimetype_description($file), 'moodle', array('class' => 'icon'));
2880             $path = file_encode_url($CFG->wwwroot.'/pluginfile.php', '/'.$context->id.'/mod_forum/attachment/'.$post->id.'/'.$filename);
2882             if ($type == 'html') {
2883                 $output .= "<a href=\"$path\">$iconimage</a> ";
2884                 $output .= "<a href=\"$path\">".s($filename)."</a>";
2885                 if ($canexport) {
2886                     $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
2887                     $button->set_format_by_file($file);
2888                     $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
2889                 }
2890                 $output .= "<br />";
2892             } else if ($type == 'text') {
2893                 $output .= "$strattachment ".s($filename).":\n$path\n";
2895             } else { //'returnimages'
2896                 if (in_array($mimetype, array('image/gif', 'image/jpeg', 'image/png'))) {
2897                     // Image attachments don't get printed as links
2898                     $imagereturn .= "<br /><img src=\"$path\" alt=\"\" />";
2899                     if ($canexport) {
2900                         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
2901                         $button->set_format_by_file($file);
2902                         $imagereturn .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
2903                     }
2904                 } else {
2905                     $output .= "<a href=\"$path\">$iconimage</a> ";
2906                     $output .= format_text("<a href=\"$path\">".s($filename)."</a>", FORMAT_HTML, array('context'=>$context));
2907                     if ($canexport) {
2908                         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
2909                         $button->set_format_by_file($file);
2910                         $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
2911                     }
2912                     $output .= '<br />';
2913                 }
2914             }
2916             if (!empty($CFG->enableplagiarism)) {
2917                 require_once($CFG->libdir.'/plagiarismlib.php');
2918                 $output .= plagiarism_get_links(array('userid' => $post->userid,
2919                     'file' => $file,
2920                     'cmid' => $cm->id,
2921                     'course' => $cm->course,
2922                     'forum' => $cm->instance));
2923                 $output .= '<br />';
2924             }
2925         }
2926     }
2928     if ($type !== 'separateimages') {
2929         return $output;
2931     } else {
2932         return array($output, $imagereturn);
2933     }
2936 ////////////////////////////////////////////////////////////////////////////////
2937 // File API                                                                   //
2938 ////////////////////////////////////////////////////////////////////////////////
2940 /**
2941  * Lists all browsable file areas
2942  *
2943  * @package  mod_forum
2944  * @category files
2945  * @param stdClass $course course object
2946  * @param stdClass $cm course module object
2947  * @param stdClass $context context object
2948  * @return array
2949  */
2950 function forum_get_file_areas($course, $cm, $context) {
2951     return array(
2952         'attachment' => get_string('areaattachment', 'mod_forum'),
2953         'post' => get_string('areapost', 'mod_forum'),
2954     );
2957 /**
2958  * File browsing support for forum module.
2959  *
2960  * @package  mod_forum
2961  * @category files
2962  * @param stdClass $browser file browser object
2963  * @param stdClass $areas file areas
2964  * @param stdClass $course course object
2965  * @param stdClass $cm course module
2966  * @param stdClass $context context module
2967  * @param string $filearea file area
2968  * @param int $itemid item ID
2969  * @param string $filepath file path
2970  * @param string $filename file name
2971  * @return file_info instance or null if not found
2972  */
2973 function forum_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
2974     global $CFG, $DB, $USER;
2976     if ($context->contextlevel != CONTEXT_MODULE) {
2977         return null;
2978     }
2980     // filearea must contain a real area
2981     if (!isset($areas[$filearea])) {
2982         return null;
2983     }
2985     // Note that forum_user_can_see_post() additionally allows access for parent roles
2986     // and it explicitly checks qanda forum type, too. One day, when we stop requiring
2987     // course:managefiles, we will need to extend this.
2988     if (!has_capability('mod/forum:viewdiscussion', $context)) {
2989         return null;
2990     }
2992     if (is_null($itemid)) {
2993         require_once($CFG->dirroot.'/mod/forum/locallib.php');
2994         return new forum_file_info_container($browser, $course, $cm, $context, $areas, $filearea);
2995     }
2997     static $cached = array();
2998     // $cached will store last retrieved post, discussion and forum. To make sure that the cache
2999     // is cleared between unit tests we check if this is the same session
3000     if (!isset($cached['sesskey']) || $cached['sesskey'] != sesskey()) {
3001         $cached = array('sesskey' => sesskey());
3002     }
3004     if (isset($cached['post']) && $cached['post']->id == $itemid) {
3005         $post = $cached['post'];
3006     } else if ($post = $DB->get_record('forum_posts', array('id' => $itemid))) {
3007         $cached['post'] = $post;
3008     } else {
3009         return null;
3010     }
3012     if (isset($cached['discussion']) && $cached['discussion']->id == $post->discussion) {
3013         $discussion = $cached['discussion'];
3014     } else if ($discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion))) {
3015         $cached['discussion'] = $discussion;
3016     } else {
3017         return null;
3018     }
3020     if (isset($cached['forum']) && $cached['forum']->id == $cm->instance) {
3021         $forum = $cached['forum'];
3022     } else if ($forum = $DB->get_record('forum', array('id' => $cm->instance))) {
3023         $cached['forum'] = $forum;
3024     } else {
3025         return null;
3026     }
3028     $fs = get_file_storage();
3029     $filepath = is_null($filepath) ? '/' : $filepath;
3030     $filename = is_null($filename) ? '.' : $filename;
3031     if (!($storedfile = $fs->get_file($context->id, 'mod_forum', $filearea, $itemid, $filepath, $filename))) {
3032         return null;
3033     }
3035     // Checks to see if the user can manage files or is the owner.
3036     // TODO MDL-33805 - Do not use userid here and move the capability check above.
3037     if (!has_capability('moodle/course:managefiles', $context) && $storedfile->get_userid() != $USER->id) {
3038         return null;
3039     }
3040     // Make sure groups allow this user to see this file
3041     if ($discussion->groupid > 0 && !has_capability('moodle/site:accessallgroups', $context)) {
3042         $groupmode = groups_get_activity_groupmode($cm, $course);
3043         if ($groupmode == SEPARATEGROUPS && !groups_is_member($discussion->groupid)) {
3044             return null;
3045         }
3046     }
3048     // Make sure we're allowed to see it...
3049     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
3050         return null;
3051     }
3053     $urlbase = $CFG->wwwroot.'/pluginfile.php';
3054     return new file_info_stored($browser, $context, $storedfile, $urlbase, $itemid, true, true, false, false);
3057 /**
3058  * Serves the forum attachments. Implements needed access control ;-)
3059  *
3060  * @package  mod_forum
3061  * @category files
3062  * @param stdClass $course course object
3063  * @param stdClass $cm course module object
3064  * @param stdClass $context context object
3065  * @param string $filearea file area
3066  * @param array $args extra arguments
3067  * @param bool $forcedownload whether or not force download
3068  * @param array $options additional options affecting the file serving
3069  * @return bool false if file not found, does not return if found - justsend the file
3070  */
3071 function forum_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
3072     global $CFG, $DB;
3074     if ($context->contextlevel != CONTEXT_MODULE) {
3075         return false;
3076     }
3078     require_course_login($course, true, $cm);
3080     $areas = forum_get_file_areas($course, $cm, $context);
3082     // filearea must contain a real area
3083     if (!isset($areas[$filearea])) {
3084         return false;
3085     }
3087     $postid = (int)array_shift($args);
3089     if (!$post = $DB->get_record('forum_posts', array('id'=>$postid))) {
3090         return false;
3091     }
3093     if (!$discussion = $DB->get_record('forum_discussions', array('id'=>$post->discussion))) {
3094         return false;
3095     }
3097     if (!$forum = $DB->get_record('forum', array('id'=>$cm->instance))) {
3098         return false;
3099     }
3101     $fs = get_file_storage();
3102     $relativepath = implode('/', $args);
3103     $fullpath = "/$context->id/mod_forum/$filearea/$postid/$relativepath";
3104     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
3105         return false;
3106     }
3108     // Make sure groups allow this user to see this file
3109     if ($discussion->groupid > 0) {
3110         $groupmode = groups_get_activity_groupmode($cm, $course);
3111         if ($groupmode == SEPARATEGROUPS) {
3112             if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
3113                 return false;
3114             }
3115         }
3116     }
3118     // Make sure we're allowed to see it...
3119     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
3120         return false;
3121     }
3123     // finally send the file
3124     send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
3127 /**
3128  * If successful, this function returns the name of the file
3129  *
3130  * @global object
3131  * @param object $post is a full post record, including course and forum
3132  * @param object $forum
3133  * @param object $cm
3134  * @param mixed $mform
3135  * @param string $unused
3136  * @return bool
3137  */
3138 function forum_add_attachment($post, $forum, $cm, $mform=null, $unused=null) {
3139     global $DB;
3141     if (empty($mform)) {
3142         return false;
3143     }
3145     if (empty($post->attachments)) {
3146         return true;   // Nothing to do
3147     }
3149     $context = context_module::instance($cm->id);
3151     $info = file_get_draft_area_info($post->attachments);
3152     $present = ($info['filecount']>0) ? '1' : '';
3153     file_save_draft_area_files($post->attachments, $context->id, 'mod_forum', 'attachment', $post->id,
3154             mod_forum_post_form::attachment_options($forum));
3156     $DB->set_field('forum_posts', 'attachment', $present, array('id'=>$post->id));
3158     return true;
3161 /**
3162  * Add a new post in an existing discussion.
3163  *
3164  * @param   stdClass    $post       The post data
3165  * @param   mixed       $mform      The submitted form
3166  * @param   string      $unused
3167  * @return int
3168  */
3169 function forum_add_new_post($post, $mform, $unused = null) {
3170     global $USER, $DB;
3172     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion));
3173     $forum      = $DB->get_record('forum', array('id' => $discussion->forum));
3174     $cm         = get_coursemodule_from_instance('forum', $forum->id);
3175     $context    = context_module::instance($cm->id);
3176     $privatereplyto = 0;
3178     // Check whether private replies should be enabled for this post.
3179     if ($post->parent) {
3180         $parent = $DB->get_record('forum_posts', array('id' => $post->parent));
3182         if (!empty($parent->privatereplyto)) {
3183             throw new \coding_exception('It should not be possible to reply to a private reply');
3184         }
3186         if (!empty($post->isprivatereply) && forum_user_can_reply_privately($context, $parent)) {
3187             $privatereplyto = $parent->userid;
3188         }
3189     }
3191     $post->created    = $post->modified = time();
3192     $post->mailed     = FORUM_MAILED_PENDING;
3193     $post->userid     = $USER->id;
3194     $post->privatereplyto = $privatereplyto;
3195     $post->attachment = "";
3196     if (!isset($post->totalscore)) {
3197         $post->totalscore = 0;
3198     }
3199     if (!isset($post->mailnow)) {
3200         $post->mailnow    = 0;
3201     }
3203     $post->id = $DB->insert_record("forum_posts", $post);
3204     $post->message = file_save_draft_area_files($post->itemid, $context->id, 'mod_forum', 'post', $post->id,
3205             mod_forum_post_form::editor_options($context, null), $post->message);
3206     $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
3207     forum_add_attachment($post, $forum, $cm, $mform);
3209     // Update discussion modified date
3210     $DB->set_field("forum_discussions", "timemodified", $post->modified, array("id" => $post->discussion));
3211     $DB->set_field("forum_discussions", "usermodified", $post->userid, array("id" => $post->discussion));
3213     if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
3214         forum_tp_mark_post_read($post->userid, $post);
3215     }
3217     if (isset($post->tags)) {
3218         core_tag_tag::set_item_tags('mod_forum', 'forum_posts', $post->id, $context, $post->tags);
3219     }
3221     // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
3222     forum_trigger_content_uploaded_event($post, $cm, 'forum_add_new_post');
3224     return $post->id;
3227 /**
3228  * Update a post.
3229  *
3230  * @param   stdClass    $newpost    The post to update
3231  * @param   mixed       $mform      The submitted form
3232  * @param   string      $unused
3233  * @return  bool
3234  */
3235 function forum_update_post($newpost, $mform, $unused = null) {
3236     global $DB, $USER;
3238     $post       = $DB->get_record('forum_posts', array('id' => $newpost->id));
3239     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion));
3240     $forum      = $DB->get_record('forum', array('id' => $discussion->forum));
3241     $cm         = get_coursemodule_from_instance('forum', $forum->id);
3242     $context    = context_module::instance($cm->id);
3244     // Allowed modifiable fields.
3245     $modifiablefields = [
3246         'subject',
3247         'message',
3248         'messageformat',
3249         'messagetrust',
3250         'timestart',
3251         'timeend',
3252         'pinned',
3253         'attachments',
3254     ];
3255     foreach ($modifiablefields as $field) {
3256         if (isset($newpost->{$field})) {
3257             $post->{$field} = $newpost->{$field};
3258         }
3259     }
3260     $post->modified = time();
3262     if (!$post->parent) {   // Post is a discussion starter - update discussion title and times too
3263         $discussion->name      = $post->subject;
3264         $discussion->timestart = $post->timestart;
3265         $discussion->timeend   = $post->timeend;
3267         if (isset($post->pinned)) {
3268             $discussion->pinned = $post->pinned;
3269         }
3270     }
3271     $post->message = file_save_draft_area_files($newpost->itemid, $context->id, 'mod_forum', 'post', $post->id,
3272             mod_forum_post_form::editor_options($context, $post->id), $post->message);
3273     $DB->update_record('forum_posts', $post);
3274     // Note: Discussion modified time/user are intentionally not updated, to enable them to track the latest new post.
3275     $DB->update_record('forum_discussions', $discussion);
3277     forum_add_attachment($post, $forum, $cm, $mform);
3279     if (isset($newpost->tags)) {
3280         core_tag_tag::set_item_tags('mod_forum', 'forum_posts', $post->id, $context, $newpost->tags);
3281     }
3283     if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
3284         forum_tp_mark_post_read($USER->id, $post);
3285     }
3287     // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
3288     forum_trigger_content_uploaded_event($post, $cm, 'forum_update_post');
3290     return true;
3293 /**
3294  * Given an object containing all the necessary data,
3295  * create a new discussion and return the id
3296  *
3297  * @param object $post
3298  * @param mixed $mform
3299  * @param string $unused
3300  * @param int $userid
3301  * @return object
3302  */
3303 function forum_add_discussion($discussion, $mform=null, $unused=null, $userid=null) {
3304     global $USER, $CFG, $DB;
3306     $timenow = isset($discussion->timenow) ? $discussion->timenow : time();
3308     if (is_null($userid)) {
3309         $userid = $USER->id;
3310     }
3312     // The first post is stored as a real post, and linked
3313     // to from the discuss entry.
3315     $forum = $DB->get_record('forum', array('id'=>$discussion->forum));
3316     $cm    = get_coursemodule_from_instance('forum', $forum->id);
3318     $post = new stdClass();
3319     $post->discussion    = 0;
3320     $post->parent        = 0;
3321     $post->privatereplyto = 0;
3322     $post->userid        = $userid;
3323     $post->created       = $timenow;
3324     $post->modified      = $timenow;
3325     $post->mailed        = FORUM_MAILED_PENDING;
3326     $post->subject       = $discussion->name;
3327     $post->message       = $discussion->message;
3328     $post->messageformat = $discussion->messageformat;
3329     $post->messagetrust  = $discussion->messagetrust;
3330     $post->attachments   = isset($discussion->attachments) ? $discussion->attachments : null;
3331     $post->forum         = $forum->id;     // speedup
3332     $post->course        = $forum->course; // speedup
3333     $post->mailnow       = $discussion->mailnow;
3335     $post->id = $DB->insert_record("forum_posts", $post);
3337     // TODO: Fix the calling code so that there always is a $cm when this function is called
3338     if (!empty($cm->id) && !empty($discussion->itemid)) {   // In "single simple discussions" this may not exist yet
3339         $context = context_module::instance($cm->id);
3340         $text = file_save_draft_area_files($discussion->itemid, $context->id, 'mod_forum', 'post', $post->id,
3341                 mod_forum_post_form::editor_options($context, null), $post->message);
3342         $DB->set_field('forum_posts', 'message', $text, array('id'=>$post->id));
3343     }
3345     // Now do the main entry for the discussion, linking to this first post
3347     $discussion->firstpost    = $post->id;
3348     $discussion->timemodified = $timenow;
3349     $discussion->usermodified = $post->userid;
3350     $discussion->userid       = $userid;
3351     $discussion->assessed     = 0;
3353     $post->discussion = $DB->insert_record("forum_discussions", $discussion);
3355     // Finally, set the pointer on the post.
3356     $DB->set_field("forum_posts", "discussion", $post->discussion, array("id"=>$post->id));
3358     if (!empty($cm->id)) {
3359         forum_add_attachment($post, $forum, $cm, $mform, $unused);
3360     }
3362     if (isset($discussion->tags)) {
3363         core_tag_tag::set_item_tags('mod_forum', 'forum_posts', $post->id, context_module::instance($cm->id), $discussion->tags);
3364     }
3366     if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
3367         forum_tp_mark_post_read($post->userid, $post);
3368     }
3370     // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
3371     if (!empty($cm->id)) {
3372         forum_trigger_content_uploaded_event($post, $cm, 'forum_add_discussion');
3373     }
3375     return $post->discussion;
3379 /**
3380  * Deletes a discussion and handles all associated cleanup.
3381  *
3382  * @global object
3383  * @param object $discussion Discussion to delete
3384  * @param bool $fulldelete True when deleting entire forum
3385  * @param object $course Course
3386  * @param object $cm Course-module
3387  * @param object $forum Forum
3388  * @return bool
3389  */
3390 function forum_delete_discussion($discussion, $fulldelete, $course, $cm, $forum) {
3391     global $DB, $CFG;
3392     require_once($CFG->libdir.'/completionlib.php');
3394     $result = true;
3396     if ($posts = $DB->get_records("forum_posts", array("discussion" => $discussion->id))) {
3397         foreach ($posts as $post) {
3398             $post->course = $discussion->course;
3399             $post->forum  = $discussion->forum;
3400             if (!forum_delete_post($post, 'ignore', $course, $cm, $forum, $fulldelete)) {
3401                 $result = false;
3402             }
3403         }
3404     }
3406     forum_tp_delete_read_records(-1, -1, $discussion->id);
3408     // Discussion subscriptions must be removed before discussions because of key constraints.
3409     $DB->delete_records('forum_discussion_subs', array('discussion' => $discussion->id));
3410     if (!$DB->delete_records("forum_discussions", array("id" => $discussion->id))) {
3411         $result = false;
3412     }
3414     // Update completion state if we are tracking completion based on number of posts
3415     // But don't bother when deleting whole thing
3416     if (!$fulldelete) {
3417         $completion = new completion_info($course);
3418         if ($completion->is_enabled($cm) == COMPLETION_TRACKING_AUTOMATIC &&
3419            ($forum->completiondiscussions || $forum->completionreplies || $forum->completionposts)) {
3420             $completion->update_state($cm, COMPLETION_INCOMPLETE, $discussion->userid);
3421         }
3422     }
3424     return $result;
3428 /**
3429  * Deletes a single forum post.
3430  *
3431  * @global object
3432  * @param object $post Forum post object
3433  * @param mixed $children Whether to delete children. If false, returns false
3434  *   if there are any children (without deleting the post). If true,
3435  *   recursively deletes all children. If set to special value 'ignore', deletes
3436  *   post regardless of children (this is for use only when deleting all posts
3437  *   in a disussion).
3438  * @param object $course Course
3439  * @param object $cm Course-module
3440  * @param object $forum Forum
3441  * @param bool $skipcompletion True to skip updating completion state if it
3442  *   would otherwise be updated, i.e. when deleting entire forum anyway.
3443  * @return bool
3444  */
3445 function forum_delete_post($post, $children, $course, $cm, $forum, $skipcompletion=false) {
3446     global $DB, $CFG, $USER;
3447     require_once($CFG->libdir.'/completionlib.php');
3449     $context = context_module::instance($cm->id);
3451     if ($children !== 'ignore' && ($childposts = $DB->get_records('forum_posts', array('parent'=>$post->id)))) {
3452        if ($children) {
3453            foreach ($childposts as $childpost) {
3454                forum_delete_post($childpost, true, $course, $cm, $forum, $skipcompletion);
3455            }
3456        } else {
3457            return false;
3458        }
3459     }
3461     // Delete ratings.
3462     require_once($CFG->dirroot.'/rating/lib.php');
3463     $delopt = new stdClass;
3464     $delopt->contextid = $context->id;
3465     $delopt->component = 'mod_forum';
3466     $delopt->ratingarea = 'post';
3467     $delopt->itemid = $post->id;
3468     $rm = new rating_manager();
3469     $rm->delete_ratings($delopt);
3471     // Delete attachments.
3472     $fs = get_file_storage();
3473     $fs->delete_area_files($context->id, 'mod_forum', 'attachment', $post->id);
3474     $fs->delete_area_files($context->id, 'mod_forum', 'post', $post->id);
3476     // Delete cached RSS feeds.
3477     if (!empty($CFG->enablerssfeeds)) {
3478         require_once($CFG->dirroot.'/mod/forum/rsslib.php');
3479         forum_rss_delete_file($forum);
3480     }
3482     if ($DB->delete_records("forum_posts", array("id" => $post->id))) {
3484         forum_tp_delete_read_records(-1, $post->id);
3486     // Just in case we are deleting the last post
3487         forum_discussion_update_last_post($post->discussion);
3489         // Update completion state if we are tracking completion based on number of posts
3490         // But don't bother when deleting whole thing
3492         if (!$skipcompletion) {
3493             $completion = new completion_info($course);
3494             if ($completion->is_enabled($cm) == COMPLETION_TRACKING_AUTOMATIC &&
3495                ($forum->completiondiscussions || $forum->completionreplies || $forum->completionposts)) {
3496                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $post->userid);
3497             }
3498         }
3500         $params = array(
3501             'context' => $context,
3502             'objectid' => $post->id,
3503             'other' => array(
3504                 'discussionid' => $post->discussion,
3505                 'forumid' => $forum->id,
3506                 'forumtype' => $forum->type,
3507             )
3508         );
3509         $post->deleted = 1;
3510         if ($post->userid !== $USER->id) {
3511             $params['relateduserid'] = $post->userid;
3512         }
3513         $event = \mod_forum\event\post_deleted::create($params);
3514         $event->add_record_snapshot('forum_posts', $post);
3515         $event->trigger();
3517         return true;
3518     }
3519     return false;
3522 /**
3523  * Sends post content to plagiarism plugin
3524  * @param object $post Forum post object
3525  * @param object $cm Course-module
3526  * @param string $name
3527  * @return bool
3528 */
3529 function forum_trigger_content_uploaded_event($post, $cm, $name) {
3530     $context = context_module::instance($cm->id);
3531     $fs = get_file_storage();
3532     $files = $fs->get_area_files($context->id, 'mod_forum', 'attachment', $post->id, "timemodified", false);
3533     $params = array(
3534         'context' => $context,
3535         'objectid' => $post->id,
3536         'other' => array(
3537             'content' => $post->message,
3538             'pathnamehashes' => array_keys($files),
3539             'discussionid' => $post->discussion,
3540             'triggeredfrom' => $name,
3541         )
3542     );
3543     $event = \mod_forum\event\assessable_uploaded::create($params);
3544     $event->trigger();
3545     return true;
3548 /**
3549  * Given a new post, subscribes or unsubscribes as appropriate.
3550  * Returns some text which describes what happened.
3551  *
3552  * @param object $fromform The submitted form
3553  * @param stdClass $forum The forum record
3554  * @param stdClass $discussion The forum discussion record
3555  * @return string
3556  */
3557 function forum_post_subscription($fromform, $forum, $discussion) {
3558     global $USER;
3560     if (\mod_forum\subscriptions::is_forcesubscribed($forum)) {
3561         return "";
3562     } else if (\mod_forum\subscriptions::subscription_disabled($forum)) {
3563         $subscribed = \mod_forum\subscriptions::is_subscribed($USER->id, $forum);
3564         if ($subscribed && !has_capability('moodle/course:manageactivities', context_course::instance($forum->course), $USER->id)) {
3565             // This user should not be subscribed to the forum.
3566             \mod_forum\subscriptions::unsubscribe_user($USER->id, $forum);
3567         }
3568         return "";
3569     }
3571     $info = new stdClass();
3572     $info->name  = fullname($USER);
3573     $info->discussion = format_string($discussion->name);
3574     $info->forum = format_string($forum->name);
3576     if (isset($fromform->discussionsubscribe) && $fromform->discussionsubscribe) {
3577         if ($result = \mod_forum\subscriptions::subscribe_user_to_discussion($USER->id, $discussion)) {
3578             return html_writer::tag('p', get_string('discussionnowsubscribed', 'forum', $info));
3579         }
3580     } else {
3581         if ($result = \mod_forum\subscriptions::unsubscribe_user_from_discussion($USER->id, $discussion)) {
3582             return html_writer::tag('p', get_string('discussionnownotsubscribed', 'forum', $info));
3583         }
3584     }
3586     return '';
3589 /**
3590  * Generate and return the subscribe or unsubscribe link for a forum.
3591  *
3592  * @param object $forum the forum. Fields used are $forum->id and $forum->forcesubscribe.
3593  * @param object $context the context object for this forum.
3594  * @param array $messages text used for the link in its various states
3595  *      (subscribed, unsubscribed, forcesubscribed or cantsubscribe).
3596  *      Any strings not passed in are taken from the $defaultmessages array
3597  *      at the top of the function.
3598  * @param bool $cantaccessagroup
3599  * @param bool $unused1
3600  * @param bool $backtoindex
3601  * @param array $unused2
3602  * @return string
3603  */
3604 function forum_get_subscribe_link($forum, $context, $messages = array(), $cantaccessagroup = false, $unused1 = true,
3605     $backtoindex = false, $unused2 = null) {
3606     global $CFG, $USER, $PAGE, $OUTPUT;
3607     $defaultmessages = array(
3608         'subscribed' => get_string('unsubscribe', 'forum'),
3609         'unsubscribed' => get_string('subscribe', 'forum'),
3610         'cantaccessgroup' => get_string('no'),
3611         'forcesubscribed' => get_string('everyoneissubscribed', 'forum'),
3612         'cantsubscribe' => get_string('disallowsubscribe','forum')
3613     );
3614     $messages = $messages + $defaultmessages;
3616     if (\mod_forum\subscriptions::is_forcesubscribed($forum)) {
3617         return $messages['forcesubscribed'];
3618     } else if (\mod_forum\subscriptions::subscription_disabled($forum) &&
3619             !has_capability('mod/forum:managesubscriptions', $context)) {
3620         return $messages['cantsubscribe'];
3621     } else if ($cantaccessagroup) {
3622         return $messages['cantaccessgroup'];
3623     } else {
3624         if (!is_enrolled($context, $USER, '', true)) {
3625             return '';
3626         }
3628         $subscribed = \mod_forum\subscriptions::is_subscribed($USER->id, $forum);
3629         if ($subscribed) {
3630             $linktext = $messages['subscribed'];
3631             $linktitle = get_string('subscribestop', 'forum');
3632         } else {
3633             $linktext = $messages['unsubscribed'];
3634             $linktitle = get_string('subscribestart', 'forum');
3635         }
3637         $options = array();
3638         if ($backtoindex) {
3639             $backtoindexlink = '&amp;backtoindex=1';
3640             $options['backtoindex'] = 1;
3641         } else {
3642             $backtoindexlink = '';
3643         }
3645         $options['id'] = $forum->id;
3646         $options['sesskey'] = sesskey();
3647         $url = new moodle_url('/mod/forum/subscribe.php', $options);
3648         return $OUTPUT->single_button($url, $linktext, 'get', array('title' => $linktitle));
3649     }
3652 /**
3653  * Returns true if user created new discussion already.
3654  *
3655  * @param int $forumid  The forum to check for postings
3656  * @param int $userid   The user to check for postings
3657  * @param int $groupid  The group to restrict the check to
3658  * @return bool
3659  */
3660 function forum_user_has_posted_discussion($forumid, $userid, $groupid = null) {
3661     global $CFG, $DB;
3663     $sql = "SELECT 'x'
3664               FROM {forum_discussions} d, {forum_posts} p
3665              WHERE d.forum = ? AND p.discussion = d.id AND p.parent = 0 AND p.userid = ?";
3667     $params = [$forumid, $userid];
3669     if ($groupid) {
3670         $sql .= " AND d.groupid = ?";
3671         $params[] = $groupid;
3672     }
3674     return $DB->record_exists_sql($sql, $params);
3677 /**
3678  * @global object
3679  * @global object
3680  * @param int $forumid
3681  * @param int $userid
3682  * @return array
3683  */
3684 function forum_discussions_user_has_posted_in($forumid, $userid) {
3685     global $CFG, $DB;
3687     $haspostedsql = "SELECT d.id AS id,
3688                             d.*
3689                        FROM {forum_posts} p,
3690                             {forum_discussions} d
3691                       WHERE p.discussion = d.id
3692                         AND d.forum = ?
3693                         AND p.userid = ?";
3695     return $DB->get_records_sql($haspostedsql, array($forumid, $userid));
3698 /**
3699  * @global object
3700  * @global object
3701  * @param int $forumid
3702  * @param int $did
3703  * @param int $userid
3704  * @return bool
3705  */
3706 function forum_user_has_posted($forumid, $did, $userid) {
3707     global $DB;
3709     if (empty($did)) {
3710         // posted in any forum discussion?
3711         $sql = "SELECT 'x'
3712                   FROM {forum_posts} p
3713                   JOIN {forum_discussions} d ON d.id = p.discussion
3714                  WHERE p.userid = :userid AND d.forum = :forumid";
3715         return $DB->record_exists_sql($sql, array('forumid'=>$forumid,'userid'=>$userid));
3716     } else {
3717         return $DB->record_exists('forum_posts', array('discussion'=>$did,'userid'=>$userid));
3718     }
3721 /**
3722  * Returns creation time of the first user's post in given discussion
3723  * @global object $DB
3724  * @param int $did Discussion id
3725  * @param int $userid User id
3726  * @return int|bool post creation time stamp or return false
3727  */
3728 function forum_get_user_posted_time($did, $userid) {
3729     global $DB;
3731     $posttime = $DB->get_field('forum_posts', 'MIN(created)', array('userid'=>$userid, 'discussion'=>$did));
3732     if (empty($posttime)) {
3733         return false;
3734     }
3735     return $posttime;
3738 /**
3739  * @global object
3740  * @param object $forum
3741  * @param object $currentgroup
3742  * @param int $unused
3743  * @param object $cm
3744  * @param object $context
3745  * @return bool
3746  */
3747 function forum_user_can_post_discussion($forum, $currentgroup=null, $unused=-1, $cm=NULL, $context=NULL) {
3748 // $forum is an object
3749     global $USER;
3751     // shortcut - guest and not-logged-in users can not post
3752     if (isguestuser() or !isloggedin()) {
3753         return false;
3754     }
3756     if (!$cm) {
3757         debugging('missing cm', DEBUG_DEVELOPER);
3758         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
3759             print_error('invalidcoursemodule');
3760         }
3761     }
3763     if (!$context) {
3764         $context = context_module::instance($cm->id);
3765     }
3767     if (forum_is_cutoff_date_reached($forum)) {
3768         if (!has_capability('mod/forum:canoverridecutoff', $context)) {
3769             return false;
3770         }
3771     }
3773     if ($currentgroup === null) {
3774         $currentgroup = groups_get_activity_group($cm);
3775     }
3777     $groupmode = groups_get_activity_groupmode($cm);
3779     if ($forum->type == 'news') {
3780         $capname = 'mod/forum:addnews';
3781     } else if ($forum->type == 'qanda') {
3782         $capname = 'mod/forum:addquestion';
3783     } else {
3784         $capname = 'mod/forum:startdiscussion';
3785     }
3787     if (!has_capability($capname, $context)) {
3788         return false;
3789     }
3791     if ($forum->type == 'single') {
3792         return false;
3793     }
3795     if ($forum->type == 'eachuser') {
3796         if (forum_user_has_posted_discussion($forum->id, $USER->id, $currentgroup)) {
3797             return false;
3798         }
3799     }
3801     if (!$groupmode or has_capability('moodle/site:accessallgroups', $context)) {
3802         return true;
3803     }
3805     if ($currentgroup) {
3806         return groups_is_member($currentgroup);
3807     } else {
3808         // no group membership and no accessallgroups means no new discussions
3809         // reverted to 1.7 behaviour in 1.9+,  buggy in 1.8.0-1.9.0
3810         return false;
3811     }
3814 /**
3815  * This function checks whether the user can reply to posts in a forum
3816  * discussion. Use forum_user_can_post_discussion() to check whether the user
3817  * can start discussions.
3818  *
3819  * @global object
3820  * @global object
3821  * @uses DEBUG_DEVELOPER
3822  * @uses CONTEXT_MODULE
3823  * @uses VISIBLEGROUPS
3824  * @param object $forum forum object
3825  * @param object $discussion
3826  * @param object $user
3827  * @param object $cm
3828  * @param object $course
3829  * @param object $context
3830  * @return bool
3831  */
3832 function forum_user_can_post($forum, $discussion, $user=NULL, $cm=NULL, $course=NULL, $context=NULL) {
3833     global $USER, $DB;
3834     if (empty($user)) {
3835         $user = $USER;
3836     }
3838     // shortcut - guest and not-logged-in users can not post
3839     if (isguestuser($user) or empty($user->id)) {
3840         return false;
3841     }
3843     if (!isset($discussion->groupid)) {
3844         debugging('incorrect discussion parameter', DEBUG_DEVELOPER);
3845         return false;
3846     }
3848     if (!$cm) {
3849         debugging('missing cm', DEBUG_DEVELOPER);
3850         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
3851             print_error('invalidcoursemodule');
3852         }
3853     }
3855     if (!$course) {
3856         debugging('missing course', DEBUG_DEVELOPER);
3857         if (!$course = $DB->get_record('course', array('id' => $forum->course))) {
3858             print_error('invalidcourseid');
3859         }
3860     }
3862     if (!$context) {
3863         $context = context_module::instance($cm->id);
3864     }
3866     if (forum_is_cutoff_date_reached($forum)) {
3867         if (!has_capability('mod/forum:canoverridecutoff', $context)) {
3868             return false;
3869         }
3870     }
3872     // Check whether the discussion is locked.
3873     if (forum_discussion_is_locked($forum, $discussion)) {
3874         if (!has_capability('mod/forum:canoverridediscussionlock', $context)) {
3875             return false;
3876         }
3877     }
3879     // normal users with temporary guest access can not post, suspended users can not post either
3880     if (!is_viewing($context, $user->id) and !is_enrolled($context, $user->id, '', true)) {
3881         return false;
3882     }
3884     if ($forum->type == 'news') {
3885         $capname = 'mod/forum:replynews';
3886     } else {
3887         $capname = 'mod/forum:replypost';
3888     }
3890     if (!has_capability($capname, $context, $user->id)) {
3891         return false;
3892     }
3894     if (!$groupmode = groups_get_activity_groupmode($cm, $course)) {
3895         return true;
3896     }
3898     if (has_capability('moodle/site:accessallgroups', $context)) {
3899         return true;
3900     }
3902     if ($groupmode == VISIBLEGROUPS) {
3903         if ($discussion->groupid == -1) {
3904             // allow students to reply to all participants discussions - this was not possible in Moodle <1.8
3905             return true;
3906         }
3907         return groups_is_member($discussion->groupid);
3909     } else {
3910         //separate groups
3911         if ($discussion->groupid == -1) {
3912             return false;
3913         }
3914         return groups_is_member($discussion->groupid);
3915     }
3918 /**
3919 * Check to ensure a user can view a timed discussion.
3921 * @param object $discussion
3922 * @param object $user
3923 * @param object $context
3924 * @return boolean returns true if they can view post, false otherwise
3925 */
3926 function forum_user_can_see_timed_discussion($discussion, $user, $context) {
3927     global $CFG;
3929     // Check that the user can view a discussion that is normally hidden due to access times.
3930     if (!empty($CFG->forum_enabletimedposts)) {
3931         $time = time();
3932         if (($discussion->timestart != 0 && $discussion->timestart > $time)
3933             || ($discussion->timeend != 0 && $discussion->timeend < $time)) {
3934             if (!has_capability('mod/forum:viewhiddentimedposts', $context, $user->id)) {
3935                 return false;
3936             }
3937         }
3938     }
3940     return true;
3943 /**
3944 * Check to ensure a user can view a group discussion.
3946 * @param object $discussion
3947 * @param object $cm
3948 * @param object $context
3949 * @return boolean returns true if they can view post, false otherwise
3950 */
3951 function forum_user_can_see_group_discussion($discussion, $cm, $context) {
3953     // If it's a grouped discussion, make sure the user is a member.
3954     if ($discussion->groupid > 0) {
3955         $groupmode = groups_get_activity_groupmode($cm);
3956         if ($groupmode == SEPARATEGROUPS) {
3957             return groups_is_member($discussion->groupid) || has_capability('moodle/site:accessallgroups', $context);
3958         }
3959     }
3961     return true;
3964 /**
3965  * @global object
3966  * @global object
3967  * @uses DEBUG_DEVELOPER
3968  * @param object $forum
3969  * @param object $discussion
3970  * @param object $context
3971  * @param object $user
3972  * @return bool
3973  */
3974 function forum_user_can_see_discussion($forum, $discussion, $context, $user=NULL) {
3975     global $USER, $DB;
3977     if (empty($user) || empty($user->id)) {
3978         $user = $USER;
3979     }
3981     // retrieve objects (yuk)
3982     if (is_numeric($forum)) {
3983         debugging('missing full forum', DEBUG_DEVELOPER);
3984         if (!$forum = $DB->get_record('forum',array('id'=>$forum))) {
3985             return false;
3986         }
3987     }
3988     if (is_numeric($discussion)) {
3989         debugging('missing full discussion', DEBUG_DEVELOPER);
3990         if (!$discussion = $DB->get_record('forum_discussions',array('id'=>$discussion))) {
3991             return false;
3992         }
3993     }
3994     if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
3995         print_error('invalidcoursemodule');
3996     }
3998     if (!has_capability('mod/forum:viewdiscussion', $context)) {
3999         return false;
4000     }
4002     if (!forum_user_can_see_timed_discussion($discussion, $user, $context)) {
4003         return false;
4004     }
4006     if (!forum_user_can_see_group_discussion($discussion, $cm, $context)) {
4007         return false;
4008     }
4010     return true;
4013 /**
4014  * Check whether a user can see the specified post.
4015  *
4016  * @param   \stdClass $forum The forum to chcek
4017  * @param   \stdClass $discussion The discussion the post is in
4018  * @param   \stdClass $post The post in question
4019  * @param   \stdClass $user The user to test - if not specified, the current user is checked.
4020  * @param   \stdClass $cm The Course Module that the forum is in (required).
4021  * @param   bool      $checkdeleted Whether to check the deleted flag on the post.
4022  * @return  bool
4023  */
4024 function forum_user_can_see_post($forum, $discussion, $post, $user = null, $cm = null, $checkdeleted = true) {
4025     global $CFG, $USER, $DB;
4027     // retrieve objects (yuk)
4028     if (is_numeric($forum)) {
4029         debugging('missing full forum', DEBUG_DEVELOPER);
4030         if (!$forum = $DB->get_record('forum',array('id'=>$forum))) {
4031             return false;
4032         }
4033     }
4035     if (is_numeric($discussion)) {
4036         debugging('missing full discussion', DEBUG_DEVELOPER);
4037         if (!$discussion = $DB->get_record('forum_discussions',array('id'=>$discussion))) {
4038             return false;
4039         }
4040     }
4041     if (is_numeric($post)) {
4042         debugging('missing full post', DEBUG_DEVELOPER);
4043         if (!$post = $DB->get_record('forum_posts',array('id'=>$post))) {
4044             return false;
4045         }
4046     }
4048     if (!isset($post->id) && isset($post->parent)) {
4049         $post->id = $post->parent;
4050     }
4052     if ($checkdeleted && !empty($post->deleted)) {
4053         return false;
4054     }
4056     if (!$cm) {
4057         debugging('missing cm', DEBUG_DEVELOPER);
4058         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
4059             print_error('invalidcoursemodule');
4060         }
4061     }
4063     // Context used throughout function.
4064     $modcontext = context_module::instance($cm->id);
4066     if (empty($user) || empty($user->id)) {
4067         $user = $USER;
4068     }
4070     $canviewdiscussion = (isset($cm->cache) && !empty($cm->cache->caps['mod/forum:viewdiscussion']))
4071         || has_capability('mod/forum:viewdiscussion', $modcontext, $user->id);
4072     if (!$canviewdiscussion && !has_all_capabilities(array('moodle/user:viewdetails', 'moodle/user:readuserposts'), context_user::instance($post->userid))) {
4073         return false;
4074     }
4076     if (!forum_post_is_visible_privately($post, $cm)) {
4077         return false;
4078     }
4080     if (isset($cm->uservisible)) {
4081         if (!$cm->uservisible) {
4082             return false;
4083         }
4084     } else {
4085         if (!\core_availability\info_module::is_user_visible($cm, $user->id, false)) {
4086             return false;
4087         }
4088     }
4090     if (!forum_user_can_see_timed_discussion($discussion, $user, $modcontext)) {
4091         return false;
4092     }
4094     if (!forum_user_can_see_group_discussion($discussion, $cm, $modcontext)) {
4095         return false;
4096     }
4098     if ($forum->type == 'qanda') {
4099         if (has_capability('mod/forum:viewqandawithoutposting', $modcontext, $user->id) || $post->userid == $user->id
4100                 || (isset($discussion->firstpost) && $discussion->firstpost == $post->id)) {
4101             return true;
4102         }
4103         $firstpost = forum_get_firstpost_from_discussion($discussion->id);
4104         if ($firstpost->userid == $user->id) {
4105             return true;
4106         }
4107         $userfirstpost = forum_get_user_posted_time($discussion->id, $user->id);
4108         return (($userfirstpost !== false && (time() - $userfirstpost >= $CFG->maxeditingtime)));
4109     }
4110     return true;
4113 /**
4114  * Returns all forum posts since a given time in specified forum.
4115  *
4116  * @todo Document this functions args
4117  * @global object
4118  * @global object
4119  * @global object
4120  * @global object
4121  */
4122 function forum_get_recent_mod_activity(&$activities, &$index, $timestart, $courseid, $cmid, $userid=0, $groupid=0)  {
4123     global $CFG, $COURSE, $USER, $DB;
4125     if ($COURSE->id == $courseid) {
4126         $course = $COURSE;
4127     } else {
4128         $course = $DB->get_record('course', array('id' => $courseid));
4129     }
4131     $modinfo = get_fast_modinfo($course);
4133     $cm = $modinfo->cms[$cmid];
4134     $params = array($timestart, $cm->instance);
4136     if ($userid) {
4137         $userselect = "AND u.id = ?";
4138         $params[] = $userid;
4139     } else {
4140         $userselect = "";
4141     }
4143     if ($groupid) {
4144         $groupselect = "AND d.groupid = ?";
4145         $params[] = $groupid;
4146     } else {
4147         $groupselect = "";
4148     }
4150     $allnames = get_all_user_name_fields(true, 'u');
4151     if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
4152                                               d.timestart, d.timeend, d.userid AS duserid,
4153                                               $allnames, u.email, u.picture, u.imagealt, u.email
4154                                          FROM {forum_posts} p
4155                                               JOIN {forum_discussions} d ON d.id = p.discussion
4156                                               JOIN {forum} f             ON f.id = d.forum
4157                                               JOIN {user} u              ON u.id = p.userid
4158                                         WHERE p.created > ? AND f.id = ?
4159                                               $userselect $groupselect
4160                                      ORDER BY p.id ASC", $params)) { // order by initial posting date
4161          return;
4162     }
4164     $groupmode       = groups_get_activity_groupmode($cm, $course);
4165     $cm_context      = context_module::instance($cm->id);
4166     $viewhiddentimed = has_capability('mod/forum:viewhiddentimedposts', $cm_context);
4167     $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
4169     $printposts = array();
4170     foreach ($posts as $post) {
4172         if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
4173           and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
4174             if (!$viewhiddentimed) {
4175                 continue;
4176             }
4177         }
4179         if ($groupmode) {
4180             if ($post->groupid == -1 or $groupmode == VISIBLEGROUPS or $accessallgroups) {
4181                 // oki (Open discussions have groupid -1)
4182             } else {
4183                 // separate mode
4184                 if (isguestuser()) {
4185                     // shortcut
4186                     continue;
4187                 }
4189                 if (!in_array($post->groupid, $modinfo->get_groups($cm->groupingid))) {
4190                     continue;
4191                 }
4192             }
4193         }
4195         $printposts[] = $post;
4196     }
4198     if (!$printposts) {
4199         return;
4200     }
4202     $aname = format_string($cm->name,true);
4204     foreach ($printposts as $post) {
4205         $tmpactivity = new stdClass();
4207         $tmpactivity->type         = 'forum';
4208         $tmpactivity->cmid         = $cm->id;
4209         $tmpactivity->name         = $aname;
4210         $tmpactivity->sectionnum   = $cm->sectionnum;
4211         $tmpactivity->timestamp    = $post->modified;
4213         $tmpactivity->content = new stdClass();
4214         $tmpactivity->content->id         = $post->id;
4215         $tmpactivity->content->discussion = $post->discussion;
4216         $tmpactivity->content->subject    = format_string($post->subject);
4217         $tmpactivity->content->parent     = $post->parent;
4218         $tmpactivity->content->forumtype  = $post->forumtype;
4220         $tmpactivity->user = new stdClass();
4221         $additionalfields = array('id' => 'userid', 'picture', 'imagealt', 'email');
4222         $additionalfields = explode(',', user_picture::fields());
4223         $tmpactivity->user = username_load_fields_from_object($tmpactivity->user, $post, null, $additionalfields);
4224         $tmpactivity->user->id = $post->userid;
4226         $activities[$index++] = $tmpactivity;
4227     }
4229     return;
4232 /**
4233  * Outputs the forum post indicated by $activity.
4234  *
4235  * @param object $activity      the activity object the forum resides in
4236  * @param int    $courseid      the id of the course the forum resides in
4237  * @param bool   $detail        not used, but required for compatibilty with other modules
4238  * @param int    $modnames      not used, but required for compatibilty with other modules
4239  * @param bool   $viewfullnames not used, but required for compatibilty with other modules
4240  */
4241 function forum_print_recent_mod_activity($activity, $courseid, $detail, $modnames, $viewfullnames) {
4242     global $OUTPUT;
4244     $content = $activity->content;
4245     if ($content->parent) {
4246         $class = 'reply';
4247     } else {
4248         $class = 'discussion';
4249     }
4251     $tableoptions = [
4252         'border' => '0',
4253         'cellpadding' => '3',
4254         'cellspacing' => '0',
4255         'class' => 'forum-recent'
4256     ];
4257     $output = html_writer::start_tag('table', $tableoptions);
4258     $output .= html_writer::start_tag('tr');
4260     $post = (object) ['parent' => $content->parent];
4261     $forum = (object) ['type' => $content->forumtype];
4262     $authorhidden = forum_is_author_hidden($post, $forum);
4264     // Show user picture if author should not be hidden.
4265     if (!$authorhidden) {
4266         $pictureoptions = [
4267             'courseid' => $courseid,
4268             'link' => $authorhidden,
4269             'alttext' => $authorhidden,
4270         ];
4271         $picture = $OUTPUT->user_picture($activity->user, $pictureoptions);
4272         $output .= html_writer::tag('td', $picture, ['class' => 'userpicture', 'valign' => 'top']);
4273     }
4275     // Discussion title and author.
4276     $output .= html_writer::start_tag('td', ['class' => $class]);
4277     if ($content->parent) {
4278         $class = 'title';
4279     } else {
4280         // Bold the title of new discussions so they stand out.
4281         $class = 'title bold';
4282     }
4284     $output .= html_writer::start_div($class);
4285     if ($detail) {
4286         $aname = s($activity->name);
4287         $output .= $OUTPUT->image_icon('icon', $aname, $activity->type);
4288     }
4289     $discussionurl = new moodle_url('/mod/forum/discuss.php', ['d' => $content->discussion]);