MDL-9469 mod_forum: add export node to settings menu
[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  * @deprecated since Moodle 3.3, when the block_course_overview block was removed.
544  */
545 function forum_filter_user_groups_discussions() {
546     throw new coding_exception('forum_filter_user_groups_discussions() can not be used any more and is obsolete.');
549 /**
550  * Returns whether the discussion group is visible by the current user or not.
551  *
552  * @since Moodle 2.8, 2.7.1, 2.6.4
553  * @param cm_info $cm The discussion course module
554  * @param int $discussiongroupid The discussion groupid
555  * @return bool
556  */
557 function forum_is_user_group_discussion(cm_info $cm, $discussiongroupid) {
559     if ($discussiongroupid == -1 || $cm->effectivegroupmode != SEPARATEGROUPS) {
560         return true;
561     }
563     if (isguestuser()) {
564         return false;
565     }
567     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id)) ||
568             in_array($discussiongroupid, $cm->get_modinfo()->get_groups($cm->groupingid))) {
569         return true;
570     }
572     return false;
575 /**
576  * @deprecated since Moodle 3.3, when the block_course_overview block was removed.
577  */
578 function forum_print_overview() {
579     throw new coding_exception('forum_print_overview() can not be used any more and is obsolete.');
582 /**
583  * Given a course and a date, prints a summary of all the new
584  * messages posted in the course since that date
585  *
586  * @global object
587  * @global object
588  * @global object
589  * @uses CONTEXT_MODULE
590  * @uses VISIBLEGROUPS
591  * @param object $course
592  * @param bool $viewfullnames capability
593  * @param int $timestart
594  * @return bool success
595  */
596 function forum_print_recent_activity($course, $viewfullnames, $timestart) {
597     global $CFG, $USER, $DB, $OUTPUT;
599     // do not use log table if possible, it may be huge and is expensive to join with other tables
601     $allnamefields = user_picture::fields('u', null, 'duserid');
602     if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
603                                               d.timestart, d.timeend, $allnamefields
604                                          FROM {forum_posts} p
605                                               JOIN {forum_discussions} d ON d.id = p.discussion
606                                               JOIN {forum} f             ON f.id = d.forum
607                                               JOIN {user} u              ON u.id = p.userid
608                                         WHERE p.created > ? AND f.course = ? AND p.deleted <> 1
609                                      ORDER BY p.id ASC", array($timestart, $course->id))) { // order by initial posting date
610          return false;
611     }
613     $modinfo = get_fast_modinfo($course);
615     $groupmodes = array();
616     $cms    = array();
618     $strftimerecent = get_string('strftimerecent');
620     $printposts = array();
621     foreach ($posts as $post) {
622         if (!isset($modinfo->instances['forum'][$post->forum])) {
623             // not visible
624             continue;
625         }
626         $cm = $modinfo->instances['forum'][$post->forum];
627         if (!$cm->uservisible) {
628             continue;
629         }
630         $context = context_module::instance($cm->id);
632         if (!has_capability('mod/forum:viewdiscussion', $context)) {
633             continue;
634         }
636         if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
637           and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
638             if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
639                 continue;
640             }
641         }
643         if (!forum_post_is_visible_privately($post, $cm)) {
644             continue;
645         }
647         // Check that the user can see the discussion.
648         if (forum_is_user_group_discussion($cm, $post->groupid)) {
649             $printposts[] = $post;
650         }
652     }
653     unset($posts);
655     if (!$printposts) {
656         return false;
657     }
659     echo $OUTPUT->heading(get_string('newforumposts', 'forum').':', 3);
660     $list = html_writer::start_tag('ul', ['class' => 'unlist']);
662     foreach ($printposts as $post) {
663         $subjectclass = empty($post->parent) ? ' bold' : '';
664         $authorhidden = forum_is_author_hidden($post, (object) ['type' => $post->forumtype]);
666         $list .= html_writer::start_tag('li');
667         $list .= html_writer::start_div('head');
668         $list .= html_writer::div(userdate_htmltime($post->modified, $strftimerecent), 'date');
669         if (!$authorhidden) {
670             $list .= html_writer::div(fullname($post, $viewfullnames), 'name');
671         }
672         $list .= html_writer::end_div(); // Head.
674         $list .= html_writer::start_div('info' . $subjectclass);
675         $discussionurl = new moodle_url('/mod/forum/discuss.php', ['d' => $post->discussion]);
676         if (!empty($post->parent)) {
677             $discussionurl->param('parent', $post->parent);
678             $discussionurl->set_anchor('p'. $post->id);
679         }
680         $post->subject = break_up_long_words(format_string($post->subject, true));
681         $list .= html_writer::link($discussionurl, $post->subject, ['rel' => 'bookmark']);
682         $list .= html_writer::end_div(); // Info.
683         $list .= html_writer::end_tag('li');
684     }
686     $list .= html_writer::end_tag('ul');
687     echo $list;
689     return true;
692 /**
693  * Return grade for given user or all users.
694  *
695  * @global object
696  * @global object
697  * @param object $forum
698  * @param int $userid optional user id, 0 means all users
699  * @return array array of grades, false if none
700  */
701 function forum_get_user_grades($forum, $userid = 0) {
702     global $CFG;
704     require_once($CFG->dirroot.'/rating/lib.php');
706     $ratingoptions = new stdClass;
707     $ratingoptions->component = 'mod_forum';
708     $ratingoptions->ratingarea = 'post';
710     //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?
711     $ratingoptions->modulename = 'forum';
712     $ratingoptions->moduleid   = $forum->id;
713     $ratingoptions->userid = $userid;
714     $ratingoptions->aggregationmethod = $forum->assessed;
715     $ratingoptions->scaleid = $forum->scale;
716     $ratingoptions->itemtable = 'forum_posts';
717     $ratingoptions->itemtableusercolumn = 'userid';
719     $rm = new rating_manager();
720     return $rm->get_user_grades($ratingoptions);
723 /**
724  * Update activity grades
725  *
726  * @category grade
727  * @param object $forum
728  * @param int $userid specific user only, 0 means all
729  * @param boolean $nullifnone return null if grade does not exist
730  * @return void
731  */
732 function forum_update_grades($forum, $userid=0, $nullifnone=true) {
733     global $CFG, $DB;
734     require_once($CFG->libdir.'/gradelib.php');
736     if (!$forum->assessed) {
737         forum_grade_item_update($forum);
739     } else if ($grades = forum_get_user_grades($forum, $userid)) {
740         forum_grade_item_update($forum, $grades);
742     } else if ($userid and $nullifnone) {
743         $grade = new stdClass();
744         $grade->userid   = $userid;
745         $grade->rawgrade = NULL;
746         forum_grade_item_update($forum, $grade);
748     } else {
749         forum_grade_item_update($forum);
750     }
753 /**
754  * Create/update grade item for given forum
755  *
756  * @category grade
757  * @uses GRADE_TYPE_NONE
758  * @uses GRADE_TYPE_VALUE
759  * @uses GRADE_TYPE_SCALE
760  * @param stdClass $forum Forum object with extra cmidnumber
761  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
762  * @return int 0 if ok
763  */
764 function forum_grade_item_update($forum, $grades=NULL) {
765     global $CFG;
766     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
767         require_once($CFG->libdir.'/gradelib.php');
768     }
770     $params = array('itemname'=>$forum->name, 'idnumber'=>$forum->cmidnumber);
772     if (!$forum->assessed or $forum->scale == 0) {
773         $params['gradetype'] = GRADE_TYPE_NONE;
775     } else if ($forum->scale > 0) {
776         $params['gradetype'] = GRADE_TYPE_VALUE;
777         $params['grademax']  = $forum->scale;
778         $params['grademin']  = 0;
780     } else if ($forum->scale < 0) {
781         $params['gradetype'] = GRADE_TYPE_SCALE;
782         $params['scaleid']   = -$forum->scale;
783     }
785     if ($grades  === 'reset') {
786         $params['reset'] = true;
787         $grades = NULL;
788     }
790     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, $grades, $params);
793 /**
794  * Delete grade item for given forum
795  *
796  * @category grade
797  * @param stdClass $forum Forum object
798  * @return grade_item
799  */
800 function forum_grade_item_delete($forum) {
801     global $CFG;
802     require_once($CFG->libdir.'/gradelib.php');
804     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, NULL, array('deleted'=>1));
807 /**
808  * Checks if scale is being used by any instance of forum
809  *
810  * This is used to find out if scale used anywhere
811  *
812  * @global object
813  * @param $scaleid int
814  * @return boolean True if the scale is used by any forum
815  */
816 function forum_scale_used_anywhere($scaleid) {
817     global $DB;
818     if ($scaleid and $DB->record_exists('forum', array('scale' => -$scaleid))) {
819         return true;
820     } else {
821         return false;
822     }
825 // SQL FUNCTIONS ///////////////////////////////////////////////////////////
827 /**
828  * Gets a post with all info ready for forum_print_post
829  * Most of these joins are just to get the forum id
830  *
831  * @global object
832  * @global object
833  * @param int $postid
834  * @return mixed array of posts or false
835  */
836 function forum_get_post_full($postid) {
837     global $CFG, $DB;
839     $allnames = get_all_user_name_fields(true, 'u');
840     return $DB->get_record_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
841                              FROM {forum_posts} p
842                                   JOIN {forum_discussions} d ON p.discussion = d.id
843                                   LEFT JOIN {user} u ON p.userid = u.id
844                             WHERE p.id = ?", array($postid));
847 /**
848  * Gets all posts in discussion including top parent.
849  *
850  * @param   int     $discussionid   The Discussion to fetch.
851  * @param   string  $sort           The sorting to apply.
852  * @param   bool    $tracking       Whether the user tracks this forum.
853  * @return  array                   The posts in the discussion.
854  */
855 function forum_get_all_discussion_posts($discussionid, $sort, $tracking = false) {
856     global $CFG, $DB, $USER;
858     $tr_sel  = "";
859     $tr_join = "";
860     $params = array();
862     if ($tracking) {
863         $tr_sel  = ", fr.id AS postread";
864         $tr_join = "LEFT JOIN {forum_read} fr ON (fr.postid = p.id AND fr.userid = ?)";
865         $params[] = $USER->id;
866     }
868     $allnames = get_all_user_name_fields(true, 'u');
869     $params[] = $discussionid;
870     if (!$posts = $DB->get_records_sql("SELECT p.*, $allnames, u.email, u.picture, u.imagealt $tr_sel
871                                      FROM {forum_posts} p
872                                           LEFT JOIN {user} u ON p.userid = u.id
873                                           $tr_join
874                                     WHERE p.discussion = ?
875                                  ORDER BY $sort", $params)) {
876         return array();
877     }
879     foreach ($posts as $pid=>$p) {
880         if ($tracking) {
881             if (forum_tp_is_post_old($p)) {
882                  $posts[$pid]->postread = true;
883             }
884         }
885         if (!$p->parent) {
886             continue;
887         }
888         if (!isset($posts[$p->parent])) {
889             continue; // parent does not exist??
890         }
891         if (!isset($posts[$p->parent]->children)) {
892             $posts[$p->parent]->children = array();
893         }
894         $posts[$p->parent]->children[$pid] =& $posts[$pid];
895     }
897     // Start with the last child of the first post.
898     $post = &$posts[reset($posts)->id];
900     $lastpost = false;
901     while (!$lastpost) {
902         if (!isset($post->children)) {
903             $post->lastpost = true;
904             $lastpost = true;
905         } else {
906              // Go to the last child of this post.
907             $post = &$posts[end($post->children)->id];
908         }
909     }
911     return $posts;
914 /**
915  * An array of forum objects that the user is allowed to read/search through.
916  *
917  * @global object
918  * @global object
919  * @global object
920  * @param int $userid
921  * @param int $courseid if 0, we look for forums throughout the whole site.
922  * @return array of forum objects, or false if no matches
923  *         Forum objects have the following attributes:
924  *         id, type, course, cmid, cmvisible, cmgroupmode, accessallgroups,
925  *         viewhiddentimedposts
926  */
927 function forum_get_readable_forums($userid, $courseid=0) {
929     global $CFG, $DB, $USER;
930     require_once($CFG->dirroot.'/course/lib.php');
932     if (!$forummod = $DB->get_record('modules', array('name' => 'forum'))) {
933         print_error('notinstalled', 'forum');
934     }
936     if ($courseid) {
937         $courses = $DB->get_records('course', array('id' => $courseid));
938     } else {
939         // If no course is specified, then the user can see SITE + his courses.
940         $courses1 = $DB->get_records('course', array('id' => SITEID));
941         $courses2 = enrol_get_users_courses($userid, true, array('modinfo'));
942         $courses = array_merge($courses1, $courses2);
943     }
944     if (!$courses) {
945         return array();
946     }
948     $readableforums = array();
950     foreach ($courses as $course) {
952         $modinfo = get_fast_modinfo($course);
954         if (empty($modinfo->instances['forum'])) {
955             // hmm, no forums?
956             continue;
957         }
959         $courseforums = $DB->get_records('forum', array('course' => $course->id));
961         foreach ($modinfo->instances['forum'] as $forumid => $cm) {
962             if (!$cm->uservisible or !isset($courseforums[$forumid])) {
963                 continue;
964             }
965             $context = context_module::instance($cm->id);
966             $forum = $courseforums[$forumid];
967             $forum->context = $context;
968             $forum->cm = $cm;
970             if (!has_capability('mod/forum:viewdiscussion', $context)) {
971                 continue;
972             }
974          /// group access
975             if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
977                 $forum->onlygroups = $modinfo->get_groups($cm->groupingid);
978                 $forum->onlygroups[] = -1;
979             }
981         /// hidden timed discussions
982             $forum->viewhiddentimedposts = true;
983             if (!empty($CFG->forum_enabletimedposts)) {
984                 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
985                     $forum->viewhiddentimedposts = false;
986                 }
987             }
989         /// qanda access
990             if ($forum->type == 'qanda'
991                     && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
993                 // We need to check whether the user has posted in the qanda forum.
994                 $forum->onlydiscussions = array();  // Holds discussion ids for the discussions
995                                                     // the user is allowed to see in this forum.
996                 if ($discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $USER->id)) {
997                     foreach ($discussionspostedin as $d) {
998                         $forum->onlydiscussions[] = $d->id;
999                     }
1000                 }
1001             }
1003             $readableforums[$forum->id] = $forum;
1004         }
1006         unset($modinfo);
1008     } // End foreach $courses
1010     return $readableforums;
1013 /**
1014  * Returns a list of posts found using an array of search terms.
1015  *
1016  * @global object
1017  * @global object
1018  * @global object
1019  * @param array $searchterms array of search terms, e.g. word +word -word
1020  * @param int $courseid if 0, we search through the whole site
1021  * @param int $limitfrom
1022  * @param int $limitnum
1023  * @param int &$totalcount
1024  * @param string $extrasql
1025  * @return array|bool Array of posts found or false
1026  */
1027 function forum_search_posts($searchterms, $courseid=0, $limitfrom=0, $limitnum=50,
1028                             &$totalcount, $extrasql='') {
1029     global $CFG, $DB, $USER;
1030     require_once($CFG->libdir.'/searchlib.php');
1032     $forums = forum_get_readable_forums($USER->id, $courseid);
1034     if (count($forums) == 0) {
1035         $totalcount = 0;
1036         return false;
1037     }
1039     $now = floor(time() / 60) * 60; // DB Cache Friendly.
1041     $fullaccess = array();
1042     $where = array();
1043     $params = array();
1045     foreach ($forums as $forumid => $forum) {
1046         $select = array();
1048         if (!$forum->viewhiddentimedposts) {
1049             $select[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
1050             $params = array_merge($params, array('userid'.$forumid=>$USER->id, 'timestart'.$forumid=>$now, 'timeend'.$forumid=>$now));
1051         }
1053         $cm = $forum->cm;
1054         $context = $forum->context;
1056         if ($forum->type == 'qanda'
1057             && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
1058             if (!empty($forum->onlydiscussions)) {
1059                 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forum->onlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
1060                 $params = array_merge($params, $discussionid_params);
1061                 $select[] = "(d.id $discussionid_sql OR p.parent = 0)";
1062             } else {
1063                 $select[] = "p.parent = 0";
1064             }
1065         }
1067         if (!empty($forum->onlygroups)) {
1068             list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($forum->onlygroups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
1069             $params = array_merge($params, $groupid_params);
1070             $select[] = "d.groupid $groupid_sql";
1071         }
1073         if ($select) {
1074             $selects = implode(" AND ", $select);
1075             $where[] = "(d.forum = :forum{$forumid} AND $selects)";
1076             $params['forum'.$forumid] = $forumid;
1077         } else {
1078             $fullaccess[] = $forumid;
1079         }
1080     }
1082     if ($fullaccess) {
1083         list($fullid_sql, $fullid_params) = $DB->get_in_or_equal($fullaccess, SQL_PARAMS_NAMED, 'fula');
1084         $params = array_merge($params, $fullid_params);
1085         $where[] = "(d.forum $fullid_sql)";
1086     }
1088     $favjoin = "";
1089     if (in_array('starredonly:on', $searchterms)) {
1090         $usercontext = context_user::instance($USER->id);
1091         $ufservice = \core_favourites\service_factory::get_service_for_user_context($usercontext);
1092         list($favjoin, $favparams) = $ufservice->get_join_sql_by_type('mod_forum', 'discussions',
1093             "favourited", "d.id");
1095         $searchterms = array_values(array_diff($searchterms, array('starredonly:on')));
1096         $params = array_merge($params, $favparams);
1097         $extrasql .= " AND favourited.itemid IS NOT NULL AND favourited.itemid != 0";
1098     }
1100     $selectdiscussion = "(".implode(" OR ", $where).")";
1102     $messagesearch = '';
1103     $searchstring = '';
1105     // Need to concat these back together for parser to work.
1106     foreach($searchterms as $searchterm){
1107         if ($searchstring != '') {
1108             $searchstring .= ' ';
1109         }
1110         $searchstring .= $searchterm;
1111     }
1113     // We need to allow quoted strings for the search. The quotes *should* be stripped
1114     // by the parser, but this should be examined carefully for security implications.
1115     $searchstring = str_replace("\\\"","\"",$searchstring);
1116     $parser = new search_parser();
1117     $lexer = new search_lexer($parser);
1119     if ($lexer->parse($searchstring)) {
1120         $parsearray = $parser->get_parsed_array();
1122         $tagjoins = '';
1123         $tagfields = [];
1124         $tagfieldcount = 0;
1125         if ($parsearray) {
1126             foreach ($parsearray as $token) {
1127                 if ($token->getType() == TOKEN_TAGS) {
1128                     for ($i = 0; $i <= substr_count($token->getValue(), ','); $i++) {
1129                         // Queries can only have a limited number of joins so set a limit sensible users won't exceed.
1130                         if ($tagfieldcount > 10) {
1131                             continue;
1132                         }
1133                         $tagjoins .= " LEFT JOIN {tag_instance} ti_$tagfieldcount
1134                                         ON p.id = ti_$tagfieldcount.itemid
1135                                             AND ti_$tagfieldcount.component = 'mod_forum'
1136                                             AND ti_$tagfieldcount.itemtype = 'forum_posts'";
1137                         $tagjoins .= " LEFT JOIN {tag} t_$tagfieldcount ON t_$tagfieldcount.id = ti_$tagfieldcount.tagid";
1138                         $tagfields[] = "t_$tagfieldcount.rawname";
1139                         $tagfieldcount++;
1140                     }
1141                 }
1142             }
1143             list($messagesearch, $msparams) = search_generate_SQL($parsearray, 'p.message', 'p.subject',
1144                 'p.userid', 'u.id', 'u.firstname',
1145                 'u.lastname', 'p.modified', 'd.forum',
1146                 $tagfields);
1148             $params = ($msparams ? array_merge($params, $msparams) : $params);
1149         }
1150     }
1152     $fromsql = "{forum_posts} p
1153                   INNER JOIN {forum_discussions} d ON d.id = p.discussion
1154                   INNER JOIN {user} u ON u.id = p.userid $tagjoins $favjoin";
1156     $selectsql = ($messagesearch ? $messagesearch . " AND " : "").
1157                 " p.discussion = d.id
1158                AND p.userid = u.id
1159                AND $selectdiscussion
1160                    $extrasql";
1162     $countsql = "SELECT COUNT(*)
1163                    FROM $fromsql
1164                   WHERE $selectsql";
1166     $allnames = get_all_user_name_fields(true, 'u');
1167     $searchsql = "SELECT p.*,
1168                          d.forum,
1169                          $allnames,
1170                          u.email,
1171                          u.picture,
1172                          u.imagealt
1173                     FROM $fromsql
1174                    WHERE $selectsql
1175                 ORDER BY p.modified DESC";
1177     $totalcount = $DB->count_records_sql($countsql, $params);
1179     return $DB->get_records_sql($searchsql, $params, $limitfrom, $limitnum);
1182 /**
1183  * Get all the posts for a user in a forum suitable for forum_print_post
1184  *
1185  * @global object
1186  * @global object
1187  * @uses CONTEXT_MODULE
1188  * @return array
1189  */
1190 function forum_get_user_posts($forumid, $userid) {
1191     global $CFG, $DB;
1193     $timedsql = "";
1194     $params = array($forumid, $userid);
1196     if (!empty($CFG->forum_enabletimedposts)) {
1197         $cm = get_coursemodule_from_instance('forum', $forumid);
1198         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
1199             $now = time();
1200             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
1201             $params[] = $now;
1202             $params[] = $now;
1203         }
1204     }
1206     $allnames = get_all_user_name_fields(true, 'u');
1207     return $DB->get_records_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1208                               FROM {forum} f
1209                                    JOIN {forum_discussions} d ON d.forum = f.id
1210                                    JOIN {forum_posts} p       ON p.discussion = d.id
1211                                    JOIN {user} u              ON u.id = p.userid
1212                              WHERE f.id = ?
1213                                    AND p.userid = ?
1214                                    $timedsql
1215                           ORDER BY p.modified ASC", $params);
1218 /**
1219  * Get all the discussions user participated in
1220  *
1221  * @global object
1222  * @global object
1223  * @uses CONTEXT_MODULE
1224  * @param int $forumid
1225  * @param int $userid
1226  * @return array Array or false
1227  */
1228 function forum_get_user_involved_discussions($forumid, $userid) {
1229     global $CFG, $DB;
1231     $timedsql = "";
1232     $params = array($forumid, $userid);
1233     if (!empty($CFG->forum_enabletimedposts)) {
1234         $cm = get_coursemodule_from_instance('forum', $forumid);
1235         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
1236             $now = time();
1237             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
1238             $params[] = $now;
1239             $params[] = $now;
1240         }
1241     }
1243     return $DB->get_records_sql("SELECT DISTINCT d.*
1244                               FROM {forum} f
1245                                    JOIN {forum_discussions} d ON d.forum = f.id
1246                                    JOIN {forum_posts} p       ON p.discussion = d.id
1247                              WHERE f.id = ?
1248                                    AND p.userid = ?
1249                                    $timedsql", $params);
1252 /**
1253  * Get all the posts for a user in a forum suitable for forum_print_post
1254  *
1255  * @global object
1256  * @global object
1257  * @param int $forumid
1258  * @param int $userid
1259  * @return array of counts or false
1260  */
1261 function forum_count_user_posts($forumid, $userid) {
1262     global $CFG, $DB;
1264     $timedsql = "";
1265     $params = array($forumid, $userid);
1266     if (!empty($CFG->forum_enabletimedposts)) {
1267         $cm = get_coursemodule_from_instance('forum', $forumid);
1268         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
1269             $now = time();
1270             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
1271             $params[] = $now;
1272             $params[] = $now;
1273         }
1274     }
1276     return $DB->get_record_sql("SELECT COUNT(p.id) AS postcount, MAX(p.modified) AS lastpost
1277                              FROM {forum} f
1278                                   JOIN {forum_discussions} d ON d.forum = f.id
1279                                   JOIN {forum_posts} p       ON p.discussion = d.id
1280                                   JOIN {user} u              ON u.id = p.userid
1281                             WHERE f.id = ?
1282                                   AND p.userid = ?
1283                                   $timedsql", $params);
1286 /**
1287  * Given a log entry, return the forum post details for it.
1288  *
1289  * @global object
1290  * @global object
1291  * @param object $log
1292  * @return array|null
1293  */
1294 function forum_get_post_from_log($log) {
1295     global $CFG, $DB;
1297     $allnames = get_all_user_name_fields(true, 'u');
1298     if ($log->action == "add post") {
1300         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
1301                                  FROM {forum_discussions} d,
1302                                       {forum_posts} p,
1303                                       {forum} f,
1304                                       {user} u
1305                                 WHERE p.id = ?
1306                                   AND d.id = p.discussion
1307                                   AND p.userid = u.id
1308                                   AND u.deleted <> '1'
1309                                   AND f.id = d.forum", array($log->info));
1312     } else if ($log->action == "add discussion") {
1314         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
1315                                  FROM {forum_discussions} d,
1316                                       {forum_posts} p,
1317                                       {forum} f,
1318                                       {user} u
1319                                 WHERE d.id = ?
1320                                   AND d.firstpost = p.id
1321                                   AND p.userid = u.id
1322                                   AND u.deleted <> '1'
1323                                   AND f.id = d.forum", array($log->info));
1324     }
1325     return NULL;
1328 /**
1329  * Given a discussion id, return the first post from the discussion
1330  *
1331  * @global object
1332  * @global object
1333  * @param int $dicsussionid
1334  * @return array
1335  */
1336 function forum_get_firstpost_from_discussion($discussionid) {
1337     global $CFG, $DB;
1339     return $DB->get_record_sql("SELECT p.*
1340                              FROM {forum_discussions} d,
1341                                   {forum_posts} p
1342                             WHERE d.id = ?
1343                               AND d.firstpost = p.id ", array($discussionid));
1346 /**
1347  * Returns an array of counts of replies to each discussion
1348  *
1349  * @param   int     $forumid
1350  * @param   string  $forumsort
1351  * @param   int     $limit
1352  * @param   int     $page
1353  * @param   int     $perpage
1354  * @param   boolean $canseeprivatereplies   Whether the current user can see private replies.
1355  * @return  array
1356  */
1357 function forum_count_discussion_replies($forumid, $forumsort = "", $limit = -1, $page = -1, $perpage = 0,
1358                                         $canseeprivatereplies = false) {
1359     global $CFG, $DB, $USER;
1361     if ($limit > 0) {
1362         $limitfrom = 0;
1363         $limitnum  = $limit;
1364     } else if ($page != -1) {
1365         $limitfrom = $page*$perpage;
1366         $limitnum  = $perpage;
1367     } else {
1368         $limitfrom = 0;
1369         $limitnum  = 0;
1370     }
1372     if ($forumsort == "") {
1373         $orderby = "";
1374         $groupby = "";
1376     } else {
1377         $orderby = "ORDER BY $forumsort";
1378         $groupby = ", ".strtolower($forumsort);
1379         $groupby = str_replace('desc', '', $groupby);
1380         $groupby = str_replace('asc', '', $groupby);
1381     }
1383     $params = ['forumid' => $forumid];
1385     if (!$canseeprivatereplies) {
1386         $privatewhere = ' AND (p.privatereplyto = :currentuser1 OR p.userid = :currentuser2 OR p.privatereplyto = 0)';
1387         $params['currentuser1'] = $USER->id;
1388         $params['currentuser2'] = $USER->id;
1389     } else {
1390         $privatewhere = '';
1391     }
1393     if (($limitfrom == 0 and $limitnum == 0) or $forumsort == "") {
1394         $sql = "SELECT p.discussion, COUNT(p.id) AS replies, MAX(p.id) AS lastpostid
1395                   FROM {forum_posts} p
1396                        JOIN {forum_discussions} d ON p.discussion = d.id
1397                  WHERE p.parent > 0 AND d.forum = :forumid
1398                        $privatewhere
1399               GROUP BY p.discussion";
1400         return $DB->get_records_sql($sql, $params);
1402     } else {
1403         $sql = "SELECT p.discussion, (COUNT(p.id) - 1) AS replies, MAX(p.id) AS lastpostid
1404                   FROM {forum_posts} p
1405                        JOIN {forum_discussions} d ON p.discussion = d.id
1406                  WHERE d.forum = :forumid
1407                        $privatewhere
1408               GROUP BY p.discussion $groupby $orderby";
1409         return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
1410     }
1413 /**
1414  * @global object
1415  * @global object
1416  * @global object
1417  * @staticvar array $cache
1418  * @param object $forum
1419  * @param object $cm
1420  * @param object $course
1421  * @return mixed
1422  */
1423 function forum_count_discussions($forum, $cm, $course) {
1424     global $CFG, $DB, $USER;
1426     static $cache = array();
1428     $now = floor(time() / 60) * 60; // DB Cache Friendly.
1430     $params = array($course->id);
1432     if (!isset($cache[$course->id])) {
1433         if (!empty($CFG->forum_enabletimedposts)) {
1434             $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
1435             $params[] = $now;
1436             $params[] = $now;
1437         } else {
1438             $timedsql = "";
1439         }
1441         $sql = "SELECT f.id, COUNT(d.id) as dcount
1442                   FROM {forum} f
1443                        JOIN {forum_discussions} d ON d.forum = f.id
1444                  WHERE f.course = ?
1445                        $timedsql
1446               GROUP BY f.id";
1448         if ($counts = $DB->get_records_sql($sql, $params)) {
1449             foreach ($counts as $count) {
1450                 $counts[$count->id] = $count->dcount;
1451             }
1452             $cache[$course->id] = $counts;
1453         } else {
1454             $cache[$course->id] = array();
1455         }
1456     }
1458     if (empty($cache[$course->id][$forum->id])) {
1459         return 0;
1460     }
1462     $groupmode = groups_get_activity_groupmode($cm, $course);
1464     if ($groupmode != SEPARATEGROUPS) {
1465         return $cache[$course->id][$forum->id];
1466     }
1468     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
1469         return $cache[$course->id][$forum->id];
1470     }
1472     require_once($CFG->dirroot.'/course/lib.php');
1474     $modinfo = get_fast_modinfo($course);
1476     $mygroups = $modinfo->get_groups($cm->groupingid);
1478     // add all groups posts
1479     $mygroups[-1] = -1;
1481     list($mygroups_sql, $params) = $DB->get_in_or_equal($mygroups);
1482     $params[] = $forum->id;
1484     if (!empty($CFG->forum_enabletimedposts)) {
1485         $timedsql = "AND d.timestart < $now AND (d.timeend = 0 OR d.timeend > $now)";
1486         $params[] = $now;
1487         $params[] = $now;
1488     } else {
1489         $timedsql = "";
1490     }
1492     $sql = "SELECT COUNT(d.id)
1493               FROM {forum_discussions} d
1494              WHERE d.groupid $mygroups_sql AND d.forum = ?
1495                    $timedsql";
1497     return $DB->get_field_sql($sql, $params);
1500 /**
1501  * Get all discussions in a forum
1502  *
1503  * @global object
1504  * @global object
1505  * @global object
1506  * @uses CONTEXT_MODULE
1507  * @uses VISIBLEGROUPS
1508  * @param object $cm
1509  * @param string $forumsort
1510  * @param bool $fullpost
1511  * @param int $unused
1512  * @param int $limit
1513  * @param bool $userlastmodified
1514  * @param int $page
1515  * @param int $perpage
1516  * @param int $groupid if groups enabled, get discussions for this group overriding the current group.
1517  *                     Use FORUM_POSTS_ALL_USER_GROUPS for all the user groups
1518  * @param int $updatedsince retrieve only discussions updated since the given time
1519  * @return array
1520  */
1521 function forum_get_discussions($cm, $forumsort="", $fullpost=true, $unused=-1, $limit=-1,
1522                                 $userlastmodified=false, $page=-1, $perpage=0, $groupid = -1,
1523                                 $updatedsince = 0) {
1524     global $CFG, $DB, $USER;
1526     $timelimit = '';
1528     $now = floor(time() / 60) * 60;
1529     $params = array($cm->instance);
1531     $modcontext = context_module::instance($cm->id);
1533     if (!has_capability('mod/forum:viewdiscussion', $modcontext)) { /// User must have perms to view discussions
1534         return array();
1535     }
1537     if (!empty($CFG->forum_enabletimedposts)) { /// Users must fulfill timed posts
1539         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
1540             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
1541             $params[] = $now;
1542             $params[] = $now;
1543             if (isloggedin()) {
1544                 $timelimit .= " OR d.userid = ?";
1545                 $params[] = $USER->id;
1546             }
1547             $timelimit .= ")";
1548         }
1549     }
1551     if ($limit > 0) {
1552         $limitfrom = 0;
1553         $limitnum  = $limit;
1554     } else if ($page != -1) {
1555         $limitfrom = $page*$perpage;
1556         $limitnum  = $perpage;
1557     } else {
1558         $limitfrom = 0;
1559         $limitnum  = 0;
1560     }
1562     $groupmode    = groups_get_activity_groupmode($cm);
1564     if ($groupmode) {
1566         if (empty($modcontext)) {
1567             $modcontext = context_module::instance($cm->id);
1568         }
1570         // Special case, we received a groupid to override currentgroup.
1571         if ($groupid > 0) {
1572             $course = get_course($cm->course);
1573             if (!groups_group_visible($groupid, $course, $cm)) {
1574                 // User doesn't belong to this group, return nothing.
1575                 return array();
1576             }
1577             $currentgroup = $groupid;
1578         } else if ($groupid === -1) {
1579             $currentgroup = groups_get_activity_group($cm);
1580         } else {
1581             // Get discussions for all groups current user can see.
1582             $currentgroup = null;
1583         }
1585         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
1586             if ($currentgroup) {
1587                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
1588                 $params[] = $currentgroup;
1589             } else {
1590                 $groupselect = "";
1591             }
1593         } else {
1594             // Separate groups.
1596             // Get discussions for all groups current user can see.
1597             if ($currentgroup === null) {
1598                 $mygroups = array_keys(groups_get_all_groups($cm->course, $USER->id, $cm->groupingid, 'g.id'));
1599                 if (empty($mygroups)) {
1600                      $groupselect = "AND d.groupid = -1";
1601                 } else {
1602                     list($insqlgroups, $inparamsgroups) = $DB->get_in_or_equal($mygroups);
1603                     $groupselect = "AND (d.groupid = -1 OR d.groupid $insqlgroups)";
1604                     $params = array_merge($params, $inparamsgroups);
1605                 }
1606             } else if ($currentgroup) {
1607                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
1608                 $params[] = $currentgroup;
1609             } else {
1610                 $groupselect = "AND d.groupid = -1";
1611             }
1612         }
1613     } else {
1614         $groupselect = "";
1615     }
1616     if (empty($forumsort)) {
1617         $forumsort = forum_get_default_sort_order();
1618     }
1619     if (empty($fullpost)) {
1620         $postdata = "p.id, p.subject, p.modified, p.discussion, p.userid, p.created";
1621     } else {
1622         $postdata = "p.*";
1623     }
1625     if (empty($userlastmodified)) {  // We don't need to know this
1626         $umfields = "";
1627         $umtable  = "";
1628     } else {
1629         $umfields = ', ' . get_all_user_name_fields(true, 'um', null, 'um') . ', um.email AS umemail, um.picture AS umpicture,
1630                         um.imagealt AS umimagealt';
1631         $umtable  = " LEFT JOIN {user} um ON (d.usermodified = um.id)";
1632     }
1634     $updatedsincesql = '';
1635     if (!empty($updatedsince)) {
1636         $updatedsincesql = 'AND d.timemodified > ?';
1637         $params[] = $updatedsince;
1638     }
1640     $discussionfields = "d.id as discussionid, d.course, d.forum, d.name, d.firstpost, d.groupid, d.assessed," .
1641     " d.timemodified, d.usermodified, d.timestart, d.timeend, d.pinned, d.timelocked";
1643     $allnames = get_all_user_name_fields(true, 'u');
1644     $sql = "SELECT $postdata, $discussionfields,
1645                    $allnames, u.email, u.picture, u.imagealt $umfields
1646               FROM {forum_discussions} d
1647                    JOIN {forum_posts} p ON p.discussion = d.id
1648                    JOIN {user} u ON p.userid = u.id
1649                    $umtable
1650              WHERE d.forum = ? AND p.parent = 0
1651                    $timelimit $groupselect $updatedsincesql
1652           ORDER BY $forumsort, d.id DESC";
1654     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
1657 /**
1658  * Gets the neighbours (previous and next) of a discussion.
1659  *
1660  * The calculation is based on the timemodified when time modified or time created is identical
1661  * It will revert to using the ID to sort consistently. This is better tha skipping a discussion.
1662  *
1663  * For blog-style forums, the calculation is based on the original creation time of the
1664  * blog post.
1665  *
1666  * Please note that this does not check whether or not the discussion passed is accessible
1667  * by the user, it simply uses it as a reference to find the neighbours. On the other hand,
1668  * the returned neighbours are checked and are accessible to the current user.
1669  *
1670  * @param object $cm The CM record.
1671  * @param object $discussion The discussion record.
1672  * @param object $forum The forum instance record.
1673  * @return array That always contains the keys 'prev' and 'next'. When there is a result
1674  *               they contain the record with minimal information such as 'id' and 'name'.
1675  *               When the neighbour is not found the value is false.
1676  */
1677 function forum_get_discussion_neighbours($cm, $discussion, $forum) {
1678     global $CFG, $DB, $USER;
1680     if ($cm->instance != $discussion->forum or $discussion->forum != $forum->id or $forum->id != $cm->instance) {
1681         throw new coding_exception('Discussion is not part of the same forum.');
1682     }
1684     $neighbours = array('prev' => false, 'next' => false);
1685     $now = floor(time() / 60) * 60;
1686     $params = array();
1688     $modcontext = context_module::instance($cm->id);
1689     $groupmode    = groups_get_activity_groupmode($cm);
1690     $currentgroup = groups_get_activity_group($cm);
1692     // Users must fulfill timed posts.
1693     $timelimit = '';
1694     if (!empty($CFG->forum_enabletimedposts)) {
1695         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
1696             $timelimit = ' AND ((d.timestart <= :tltimestart AND (d.timeend = 0 OR d.timeend > :tltimeend))';
1697             $params['tltimestart'] = $now;
1698             $params['tltimeend'] = $now;
1699             if (isloggedin()) {
1700                 $timelimit .= ' OR d.userid = :tluserid';
1701                 $params['tluserid'] = $USER->id;
1702             }
1703             $timelimit .= ')';
1704         }
1705     }
1707     // Limiting to posts accessible according to groups.
1708     $groupselect = '';
1709     if ($groupmode) {
1710         if ($groupmode == VISIBLEGROUPS || has_capability('moodle/site:accessallgroups', $modcontext)) {
1711             if ($currentgroup) {
1712                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
1713                 $params['groupid'] = $currentgroup;
1714             }
1715         } else {
1716             if ($currentgroup) {
1717                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
1718                 $params['groupid'] = $currentgroup;
1719             } else {
1720                 $groupselect = 'AND d.groupid = -1';
1721             }
1722         }
1723     }
1725     $params['forumid'] = $cm->instance;
1726     $params['discid1'] = $discussion->id;
1727     $params['discid2'] = $discussion->id;
1728     $params['discid3'] = $discussion->id;
1729     $params['discid4'] = $discussion->id;
1730     $params['disctimecompare1'] = $discussion->timemodified;
1731     $params['disctimecompare2'] = $discussion->timemodified;
1732     $params['pinnedstate1'] = (int) $discussion->pinned;
1733     $params['pinnedstate2'] = (int) $discussion->pinned;
1734     $params['pinnedstate3'] = (int) $discussion->pinned;
1735     $params['pinnedstate4'] = (int) $discussion->pinned;
1737     $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
1738               FROM {forum_discussions} d
1739               JOIN {forum_posts} p ON d.firstpost = p.id
1740              WHERE d.forum = :forumid
1741                AND d.id <> :discid1
1742                    $timelimit
1743                    $groupselect";
1744     $comparefield = "d.timemodified";
1745     $comparevalue = ":disctimecompare1";
1746     $comparevalue2  = ":disctimecompare2";
1747     if (!empty($CFG->forum_enabletimedposts)) {
1748         // Here we need to take into account the release time (timestart)
1749         // if one is set, of the neighbouring posts and compare it to the
1750         // timestart or timemodified of *this* post depending on if the
1751         // release date of this post is in the future or not.
1752         // This stops discussions that appear later because of the
1753         // timestart value from being buried under discussions that were
1754         // made afterwards.
1755         $comparefield = "CASE WHEN d.timemodified < d.timestart
1756                                 THEN d.timestart ELSE d.timemodified END";
1757         if ($discussion->timemodified < $discussion->timestart) {
1758             // Normally we would just use the timemodified for sorting
1759             // discussion posts. However, when timed discussions are enabled,
1760             // then posts need to be sorted base on the later of timemodified
1761             // or the release date of the post (timestart).
1762             $params['disctimecompare1'] = $discussion->timestart;
1763             $params['disctimecompare2'] = $discussion->timestart;
1764         }
1765     }
1766     $orderbydesc = forum_get_default_sort_order(true, $comparefield, 'd', false);
1767     $orderbyasc = forum_get_default_sort_order(false, $comparefield, 'd', false);
1769     if ($forum->type === 'blog') {
1770          $subselect = "SELECT pp.created
1771                    FROM {forum_discussions} dd
1772                    JOIN {forum_posts} pp ON dd.firstpost = pp.id ";
1774          $subselectwhere1 = " WHERE dd.id = :discid3";
1775          $subselectwhere2 = " WHERE dd.id = :discid4";
1777          $comparefield = "p.created";
1779          $sub1 = $subselect.$subselectwhere1;
1780          $comparevalue = "($sub1)";
1782          $sub2 = $subselect.$subselectwhere2;
1783          $comparevalue2 = "($sub2)";
1785          $orderbydesc = "d.pinned, p.created DESC";
1786          $orderbyasc = "d.pinned, p.created ASC";
1787     }
1789     $prevsql = $sql . " AND ( (($comparefield < $comparevalue) AND :pinnedstate1 = d.pinned)
1790                          OR ($comparefield = $comparevalue2 AND (d.pinned = 0 OR d.pinned = :pinnedstate4) AND d.id < :discid2)
1791                          OR (d.pinned = 0 AND d.pinned <> :pinnedstate2))
1792                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbydesc, d.id DESC";
1794     $nextsql = $sql . " AND ( (($comparefield > $comparevalue) AND :pinnedstate1 = d.pinned)
1795                          OR ($comparefield = $comparevalue2 AND (d.pinned = 1 OR d.pinned = :pinnedstate4) AND d.id > :discid2)
1796                          OR (d.pinned = 1 AND d.pinned <> :pinnedstate2))
1797                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbyasc, d.id ASC";
1799     $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
1800     $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
1801     return $neighbours;
1804 /**
1805  * Get the sql to use in the ORDER BY clause for forum discussions.
1806  *
1807  * This has the ordering take timed discussion windows into account.
1808  *
1809  * @param bool $desc True for DESC, False for ASC.
1810  * @param string $compare The field in the SQL to compare to normally sort by.
1811  * @param string $prefix The prefix being used for the discussion table.
1812  * @param bool $pinned sort pinned posts to the top
1813  * @return string
1814  */
1815 function forum_get_default_sort_order($desc = true, $compare = 'd.timemodified', $prefix = 'd', $pinned = true) {
1816     global $CFG;
1818     if (!empty($prefix)) {
1819         $prefix .= '.';
1820     }
1822     $dir = $desc ? 'DESC' : 'ASC';
1824     if ($pinned == true) {
1825         $pinned = "{$prefix}pinned DESC,";
1826     } else {
1827         $pinned = '';
1828     }
1830     $sort = "{$prefix}timemodified";
1831     if (!empty($CFG->forum_enabletimedposts)) {
1832         $sort = "CASE WHEN {$compare} < {$prefix}timestart
1833                  THEN {$prefix}timestart
1834                  ELSE {$compare}
1835                  END";
1836     }
1837     return "$pinned $sort $dir";
1840 /**
1841  *
1842  * @global object
1843  * @global object
1844  * @global object
1845  * @uses CONTEXT_MODULE
1846  * @uses VISIBLEGROUPS
1847  * @param object $cm
1848  * @return array
1849  */
1850 function forum_get_discussions_unread($cm) {
1851     global $CFG, $DB, $USER;
1853     $now = floor(time() / 60) * 60;
1854     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
1856     $params = array();
1857     $groupmode    = groups_get_activity_groupmode($cm);
1858     $currentgroup = groups_get_activity_group($cm);
1860     if ($groupmode) {
1861         $modcontext = context_module::instance($cm->id);
1863         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
1864             if ($currentgroup) {
1865                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
1866                 $params['currentgroup'] = $currentgroup;
1867             } else {
1868                 $groupselect = "";
1869             }
1871         } else {
1872             //separate groups without access all
1873             if ($currentgroup) {
1874                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
1875                 $params['currentgroup'] = $currentgroup;
1876             } else {
1877                 $groupselect = "AND d.groupid = -1";
1878             }
1879         }
1880     } else {
1881         $groupselect = "";
1882     }
1884     if (!empty($CFG->forum_enabletimedposts)) {
1885         $timedsql = "AND d.timestart < :now1 AND (d.timeend = 0 OR d.timeend > :now2)";
1886         $params['now1'] = $now;
1887         $params['now2'] = $now;
1888     } else {
1889         $timedsql = "";
1890     }
1892     $sql = "SELECT d.id, COUNT(p.id) AS unread
1893               FROM {forum_discussions} d
1894                    JOIN {forum_posts} p     ON p.discussion = d.id
1895                    LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = $USER->id)
1896              WHERE d.forum = {$cm->instance}
1897                    AND p.modified >= :cutoffdate AND r.id is NULL
1898                    $groupselect
1899                    $timedsql
1900           GROUP BY d.id";
1901     $params['cutoffdate'] = $cutoffdate;
1903     if ($unreads = $DB->get_records_sql($sql, $params)) {
1904         foreach ($unreads as $unread) {
1905             $unreads[$unread->id] = $unread->unread;
1906         }
1907         return $unreads;
1908     } else {
1909         return array();
1910     }
1913 /**
1914  * @global object
1915  * @global object
1916  * @global object
1917  * @uses CONEXT_MODULE
1918  * @uses VISIBLEGROUPS
1919  * @param object $cm
1920  * @return array
1921  */
1922 function forum_get_discussions_count($cm) {
1923     global $CFG, $DB, $USER;
1925     $now = floor(time() / 60) * 60;
1926     $params = array($cm->instance);
1927     $groupmode    = groups_get_activity_groupmode($cm);
1928     $currentgroup = groups_get_activity_group($cm);
1930     if ($groupmode) {
1931         $modcontext = context_module::instance($cm->id);
1933         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
1934             if ($currentgroup) {
1935                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
1936                 $params[] = $currentgroup;
1937             } else {
1938                 $groupselect = "";
1939             }
1941         } else {
1942             //seprate groups without access all
1943             if ($currentgroup) {
1944                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
1945                 $params[] = $currentgroup;
1946             } else {
1947                 $groupselect = "AND d.groupid = -1";
1948             }
1949         }
1950     } else {
1951         $groupselect = "";
1952     }
1954     $timelimit = "";
1956     if (!empty($CFG->forum_enabletimedposts)) {
1958         $modcontext = context_module::instance($cm->id);
1960         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
1961             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
1962             $params[] = $now;
1963             $params[] = $now;
1964             if (isloggedin()) {
1965                 $timelimit .= " OR d.userid = ?";
1966                 $params[] = $USER->id;
1967             }
1968             $timelimit .= ")";
1969         }
1970     }
1972     $sql = "SELECT COUNT(d.id)
1973               FROM {forum_discussions} d
1974                    JOIN {forum_posts} p ON p.discussion = d.id
1975              WHERE d.forum = ? AND p.parent = 0
1976                    $groupselect $timelimit";
1978     return $DB->get_field_sql($sql, $params);
1982 // OTHER FUNCTIONS ///////////////////////////////////////////////////////////
1985 /**
1986  * @global object
1987  * @global object
1988  * @param int $courseid
1989  * @param string $type
1990  */
1991 function forum_get_course_forum($courseid, $type) {
1992 // How to set up special 1-per-course forums
1993     global $CFG, $DB, $OUTPUT, $USER;
1995     if ($forums = $DB->get_records_select("forum", "course = ? AND type = ?", array($courseid, $type), "id ASC")) {
1996         // There should always only be ONE, but with the right combination of
1997         // errors there might be more.  In this case, just return the oldest one (lowest ID).
1998         foreach ($forums as $forum) {
1999             return $forum;   // ie the first one
2000         }
2001     }
2003     // Doesn't exist, so create one now.
2004     $forum = new stdClass();
2005     $forum->course = $courseid;
2006     $forum->type = "$type";
2007     if (!empty($USER->htmleditor)) {
2008         $forum->introformat = $USER->htmleditor;
2009     }
2010     switch ($forum->type) {
2011         case "news":
2012             $forum->name  = get_string("namenews", "forum");
2013             $forum->intro = get_string("intronews", "forum");
2014             $forum->introformat = FORMAT_HTML;
2015             $forum->forcesubscribe = FORUM_FORCESUBSCRIBE;
2016             $forum->assessed = 0;
2017             if ($courseid == SITEID) {
2018                 $forum->name  = get_string("sitenews");
2019                 $forum->forcesubscribe = 0;
2020             }
2021             break;
2022         case "social":
2023             $forum->name  = get_string("namesocial", "forum");
2024             $forum->intro = get_string("introsocial", "forum");
2025             $forum->introformat = FORMAT_HTML;
2026             $forum->assessed = 0;
2027             $forum->forcesubscribe = 0;
2028             break;
2029         case "blog":
2030             $forum->name = get_string('blogforum', 'forum');
2031             $forum->intro = get_string('introblog', 'forum');
2032             $forum->introformat = FORMAT_HTML;
2033             $forum->assessed = 0;
2034             $forum->forcesubscribe = 0;
2035             break;
2036         default:
2037             echo $OUTPUT->notification("That forum type doesn't exist!");
2038             return false;
2039             break;
2040     }
2042     $forum->timemodified = time();
2043     $forum->id = $DB->insert_record("forum", $forum);
2045     if (! $module = $DB->get_record("modules", array("name" => "forum"))) {
2046         echo $OUTPUT->notification("Could not find forum module!!");
2047         return false;
2048     }
2049     $mod = new stdClass();
2050     $mod->course = $courseid;
2051     $mod->module = $module->id;
2052     $mod->instance = $forum->id;
2053     $mod->section = 0;
2054     include_once("$CFG->dirroot/course/lib.php");
2055     if (! $mod->coursemodule = add_course_module($mod) ) {
2056         echo $OUTPUT->notification("Could not add a new course module to the course '" . $courseid . "'");
2057         return false;
2058     }
2059     $sectionid = course_add_cm_to_section($courseid, $mod->coursemodule, 0);
2060     return $DB->get_record("forum", array("id" => "$forum->id"));
2063 /**
2064  * Return rating related permissions
2065  *
2066  * @param string $options the context id
2067  * @return array an associative array of the user's rating permissions
2068  */
2069 function forum_rating_permissions($contextid, $component, $ratingarea) {
2070     $context = context::instance_by_id($contextid, MUST_EXIST);
2071     if ($component != 'mod_forum' || $ratingarea != 'post') {
2072         // We don't know about this component/ratingarea so just return null to get the
2073         // default restrictive permissions.
2074         return null;
2075     }
2076     return array(
2077         'view'    => has_capability('mod/forum:viewrating', $context),
2078         'viewany' => has_capability('mod/forum:viewanyrating', $context),
2079         'viewall' => has_capability('mod/forum:viewallratings', $context),
2080         'rate'    => has_capability('mod/forum:rate', $context)
2081     );
2084 /**
2085  * Validates a submitted rating
2086  * @param array $params submitted data
2087  *            context => object the context in which the rated items exists [required]
2088  *            component => The component for this module - should always be mod_forum [required]
2089  *            ratingarea => object the context in which the rated items exists [required]
2090  *
2091  *            itemid => int the ID of the object being rated [required]
2092  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
2093  *            rating => int the submitted rating [required]
2094  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
2095  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
2096  * @return boolean true if the rating is valid. Will throw rating_exception if not
2097  */
2098 function forum_rating_validate($params) {
2099     global $DB, $USER;
2101     // Check the component is mod_forum
2102     if ($params['component'] != 'mod_forum') {
2103         throw new rating_exception('invalidcomponent');
2104     }
2106     // Check the ratingarea is post (the only rating area in forum)
2107     if ($params['ratingarea'] != 'post') {
2108         throw new rating_exception('invalidratingarea');
2109     }
2111     // Check the rateduserid is not the current user .. you can't rate your own posts
2112     if ($params['rateduserid'] == $USER->id) {
2113         throw new rating_exception('nopermissiontorate');
2114     }
2116     // Fetch all the related records ... we need to do this anyway to call forum_user_can_see_post
2117     $post = $DB->get_record('forum_posts', array('id' => $params['itemid'], 'userid' => $params['rateduserid']), '*', MUST_EXIST);
2118     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion), '*', MUST_EXIST);
2119     $forum = $DB->get_record('forum', array('id' => $discussion->forum), '*', MUST_EXIST);
2120     $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
2121     $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id , false, MUST_EXIST);
2122     $context = context_module::instance($cm->id);
2124     // Make sure the context provided is the context of the forum
2125     if ($context->id != $params['context']->id) {
2126         throw new rating_exception('invalidcontext');
2127     }
2129     if ($forum->scale != $params['scaleid']) {
2130         //the scale being submitted doesnt match the one in the database
2131         throw new rating_exception('invalidscaleid');
2132     }
2134     // check the item we're rating was created in the assessable time window
2135     if (!empty($forum->assesstimestart) && !empty($forum->assesstimefinish)) {
2136         if ($post->created < $forum->assesstimestart || $post->created > $forum->assesstimefinish) {
2137             throw new rating_exception('notavailable');
2138         }
2139     }
2141     //check that the submitted rating is valid for the scale
2143     // lower limit
2144     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
2145         throw new rating_exception('invalidnum');
2146     }
2148     // upper limit
2149     if ($forum->scale < 0) {
2150         //its a custom scale
2151         $scalerecord = $DB->get_record('scale', array('id' => -$forum->scale));
2152         if ($scalerecord) {
2153             $scalearray = explode(',', $scalerecord->scale);
2154             if ($params['rating'] > count($scalearray)) {
2155                 throw new rating_exception('invalidnum');
2156             }
2157         } else {
2158             throw new rating_exception('invalidscaleid');
2159         }
2160     } else if ($params['rating'] > $forum->scale) {
2161         //if its numeric and submitted rating is above maximum
2162         throw new rating_exception('invalidnum');
2163     }
2165     // Make sure groups allow this user to see the item they're rating
2166     if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
2167         if (!groups_group_exists($discussion->groupid)) { // Can't find group
2168             throw new rating_exception('cannotfindgroup');//something is wrong
2169         }
2171         if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
2172             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
2173             throw new rating_exception('notmemberofgroup');
2174         }
2175     }
2177     // perform some final capability checks
2178     if (!forum_user_can_see_post($forum, $discussion, $post, $USER, $cm)) {
2179         throw new rating_exception('nopermissiontorate');
2180     }
2182     return true;
2185 /**
2186  * Can the current user see ratings for a given itemid?
2187  *
2188  * @param array $params submitted data
2189  *            contextid => int contextid [required]
2190  *            component => The component for this module - should always be mod_forum [required]
2191  *            ratingarea => object the context in which the rated items exists [required]
2192  *            itemid => int the ID of the object being rated [required]
2193  *            scaleid => int scale id [optional]
2194  * @return bool
2195  * @throws coding_exception
2196  * @throws rating_exception
2197  */
2198 function mod_forum_rating_can_see_item_ratings($params) {
2199     global $DB, $USER;
2201     // Check the component is mod_forum.
2202     if (!isset($params['component']) || $params['component'] != 'mod_forum') {
2203         throw new rating_exception('invalidcomponent');
2204     }
2206     // Check the ratingarea is post (the only rating area in forum).
2207     if (!isset($params['ratingarea']) || $params['ratingarea'] != 'post') {
2208         throw new rating_exception('invalidratingarea');
2209     }
2211     if (!isset($params['itemid'])) {
2212         throw new rating_exception('invaliditemid');
2213     }
2215     $post = $DB->get_record('forum_posts', array('id' => $params['itemid']), '*', MUST_EXIST);
2216     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion), '*', MUST_EXIST);
2217     $forum = $DB->get_record('forum', array('id' => $discussion->forum), '*', MUST_EXIST);
2218     $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
2219     $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id , false, MUST_EXIST);
2221     // Perform some final capability checks.
2222     if (!forum_user_can_see_post($forum, $discussion, $post, $USER, $cm)) {
2223         return false;
2224     }
2226     return true;
2229 /**
2230  * This function prints the overview of a discussion in the forum listing.
2231  * It needs some discussion information and some post information, these
2232  * happen to be combined for efficiency in the $post parameter by the function
2233  * that calls this one: forum_print_latest_discussions()
2234  *
2235  * @global object
2236  * @global object
2237  * @param object $post The post object (passed by reference for speed).
2238  * @param object $forum The forum object.
2239  * @param int $group Current group.
2240  * @param string $datestring Format to use for the dates.
2241  * @param boolean $cantrack Is tracking enabled for this forum.
2242  * @param boolean $forumtracked Is the user tracking this forum.
2243  * @param boolean $canviewparticipants True if user has the viewparticipants permission for this course
2244  * @param boolean $canviewhiddentimedposts True if user has the viewhiddentimedposts permission for this forum
2245  */
2246 function forum_print_discussion_header(&$post, $forum, $group = -1, $datestring = "",
2247                                         $cantrack = true, $forumtracked = true, $canviewparticipants = true, $modcontext = null,
2248                                         $canviewhiddentimedposts = false) {
2250     global $COURSE, $USER, $CFG, $OUTPUT, $PAGE;
2252     static $rowcount;
2253     static $strmarkalldread;
2255     if (empty($modcontext)) {
2256         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
2257             print_error('invalidcoursemodule');
2258         }
2259         $modcontext = context_module::instance($cm->id);
2260     }
2262     if (!isset($rowcount)) {
2263         $rowcount = 0;
2264         $strmarkalldread = get_string('markalldread', 'forum');
2265     } else {
2266         $rowcount = ($rowcount + 1) % 2;
2267     }
2269     $post->subject = format_string($post->subject,true);
2271     $canviewfullnames = has_capability('moodle/site:viewfullnames', $modcontext);
2272     $timeddiscussion = !empty($CFG->forum_enabletimedposts) && ($post->timestart || $post->timeend);
2273     $timedoutsidewindow = '';
2274     if ($timeddiscussion && ($post->timestart > time() || ($post->timeend != 0 && $post->timeend < time()))) {
2275         $timedoutsidewindow = ' dimmed_text';
2276     }
2278     echo "\n\n";
2279     echo '<tr class="discussion r'.$rowcount.$timedoutsidewindow.'">';
2281     $topicclass = 'topic starter';
2282     if (FORUM_DISCUSSION_PINNED == $post->pinned) {
2283         $topicclass .= ' pinned';
2284     }
2285     echo '<td class="'.$topicclass.'">';
2286     if (FORUM_DISCUSSION_PINNED == $post->pinned) {
2287         echo $OUTPUT->pix_icon('i/pinned', get_string('discussionpinned', 'forum'), 'mod_forum');
2288     }
2289     $canalwaysseetimedpost = $USER->id == $post->userid || $canviewhiddentimedposts;
2290     if ($timeddiscussion && $canalwaysseetimedpost) {
2291         echo $PAGE->get_renderer('mod_forum')->timed_discussion_tooltip($post, empty($timedoutsidewindow));
2292     }
2294     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">'.$post->subject.'</a>';
2295     echo "</td>\n";
2297     // Picture
2298     $postuser = new stdClass();
2299     $postuserfields = explode(',', user_picture::fields());
2300     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
2301     $postuser->id = $post->userid;
2302     echo '<td class="author">';
2303     echo '<div class="media">';
2304     echo '<span class="float-left">';
2305     echo $OUTPUT->user_picture($postuser, array('courseid'=>$forum->course));
2306     echo '</span>';
2307     // User name
2308     echo '<div class="media-body">';
2309     $fullname = fullname($postuser, $canviewfullnames);
2310     echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->userid.'&amp;course='.$forum->course.'">'.$fullname.'</a>';
2311     echo '</div>';
2312     echo '</div>';
2313     echo "</td>\n";
2315     // Group picture
2316     if ($group !== -1) {  // Groups are active - group is a group data object or NULL
2317         echo '<td class="picture group">';
2318         if (!empty($group->picture) and empty($group->hidepicture)) {
2319             if ($canviewparticipants && $COURSE->groupmode) {
2320                 $picturelink = true;
2321             } else {
2322                 $picturelink = false;
2323             }
2324             print_group_picture($group, $forum->course, false, false, $picturelink);
2325         } else if (isset($group->id)) {
2326             if ($canviewparticipants && $COURSE->groupmode) {
2327                 echo '<a href="'.$CFG->wwwroot.'/user/index.php?id='.$forum->course.'&amp;group='.$group->id.'">'.$group->name.'</a>';
2328             } else {
2329                 echo $group->name;
2330             }
2331         }
2332         echo "</td>\n";
2333     }
2335     if (has_capability('mod/forum:viewdiscussion', $modcontext)) {   // Show the column with replies
2336         echo '<td class="replies">';
2337         echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
2338         echo $post->replies.'</a>';
2339         echo "</td>\n";
2341         if ($cantrack) {
2342             echo '<td class="replies">';
2343             if ($forumtracked) {
2344                 if ($post->unread > 0) {
2345                     echo '<span class="unread">';
2346                     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'#unread">';
2347                     echo $post->unread;
2348                     echo '</a>';
2349                     echo '<a title="'.$strmarkalldread.'" href="'.$CFG->wwwroot.'/mod/forum/markposts.php?f='.
2350                          $forum->id.'&amp;d='.$post->discussion.'&amp;mark=read&amp;return=/mod/forum/view.php&amp;sesskey=' .
2351                          sesskey() . '">' . $OUTPUT->pix_icon('t/markasread', $strmarkalldread) . '</a>';
2352                     echo '</span>';
2353                 } else {
2354                     echo '<span class="read">';
2355                     echo $post->unread;
2356                     echo '</span>';
2357                 }
2358             } else {
2359                 echo '<span class="read">';
2360                 echo '-';
2361                 echo '</span>';
2362             }
2363             echo "</td>\n";
2364         }
2365     }
2367     echo '<td class="lastpost">';
2368     $usedate = (empty($post->timemodified)) ? $post->created : $post->timemodified;
2369     $parenturl = '';
2370     $usermodified = new stdClass();
2371     $usermodified->id = $post->usermodified;
2372     $usermodified = username_load_fields_from_object($usermodified, $post, 'um');
2374     // In QA forums we check that the user can view participants.
2375     if ($forum->type !== 'qanda' || $canviewparticipants) {
2376         echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->usermodified.'&amp;course='.$forum->course.'">'.
2377              fullname($usermodified, $canviewfullnames).'</a><br />';
2378         $parenturl = (empty($post->lastpostid)) ? '' : '&amp;parent='.$post->lastpostid;
2379     }
2381     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.$parenturl.'">'.
2382           userdate_htmltime($usedate, $datestring).'</a>';
2383     echo "</td>\n";
2385     // is_guest should be used here as this also checks whether the user is a guest in the current course.
2386     // Guests and visitors cannot subscribe - only enrolled users.
2387     if ((!is_guest($modcontext, $USER) && isloggedin()) && has_capability('mod/forum:viewdiscussion', $modcontext)) {
2388         // Discussion subscription.
2389         if (\mod_forum\subscriptions::is_subscribable($forum)) {
2390             echo '<td class="discussionsubscription">';
2391             echo forum_get_discussion_subscription_icon($forum, $post->discussion);
2392             echo '</td>';
2393         }
2394     }
2396     echo "</tr>\n\n";
2400 /**
2401  * Return the markup for the discussion subscription toggling icon.
2402  *
2403  * @param stdClass $forum The forum object.
2404  * @param int $discussionid The discussion to create an icon for.
2405  * @return string The generated markup.
2406  */
2407 function forum_get_discussion_subscription_icon($forum, $discussionid, $returnurl = null, $includetext = false) {
2408     global $USER, $OUTPUT, $PAGE;
2410     if ($returnurl === null && $PAGE->url) {
2411         $returnurl = $PAGE->url->out();
2412     }
2414     $o = '';
2415     $subscriptionstatus = \mod_forum\subscriptions::is_subscribed($USER->id, $forum, $discussionid);
2416     $subscriptionlink = new moodle_url('/mod/forum/subscribe.php', array(
2417         'sesskey' => sesskey(),
2418         'id' => $forum->id,
2419         'd' => $discussionid,
2420         'returnurl' => $returnurl,
2421     ));
2423     if ($includetext) {
2424         $o .= $subscriptionstatus ? get_string('subscribed', 'mod_forum') : get_string('notsubscribed', 'mod_forum');
2425     }
2427     if ($subscriptionstatus) {
2428         $output = $OUTPUT->pix_icon('t/subscribed', get_string('clicktounsubscribe', 'forum'), 'mod_forum');
2429         if ($includetext) {
2430             $output .= get_string('subscribed', 'mod_forum');
2431         }
2433         return html_writer::link($subscriptionlink, $output, array(
2434                 'title' => get_string('clicktounsubscribe', 'forum'),
2435                 'class' => 'discussiontoggle iconsmall',
2436                 'data-forumid' => $forum->id,
2437                 'data-discussionid' => $discussionid,
2438                 'data-includetext' => $includetext,
2439             ));
2441     } else {
2442         $output = $OUTPUT->pix_icon('t/unsubscribed', get_string('clicktosubscribe', 'forum'), 'mod_forum');
2443         if ($includetext) {
2444             $output .= get_string('notsubscribed', 'mod_forum');
2445         }
2447         return html_writer::link($subscriptionlink, $output, array(
2448                 'title' => get_string('clicktosubscribe', 'forum'),
2449                 'class' => 'discussiontoggle iconsmall',
2450                 'data-forumid' => $forum->id,
2451                 'data-discussionid' => $discussionid,
2452                 'data-includetext' => $includetext,
2453             ));
2454     }
2457 /**
2458  * Return a pair of spans containing classes to allow the subscribe and
2459  * unsubscribe icons to be pre-loaded by a browser.
2460  *
2461  * @return string The generated markup
2462  */
2463 function forum_get_discussion_subscription_icon_preloaders() {
2464     $o = '';
2465     $o .= html_writer::span('&nbsp;', 'preload-subscribe');
2466     $o .= html_writer::span('&nbsp;', 'preload-unsubscribe');
2467     return $o;
2470 /**
2471  * Print the drop down that allows the user to select how they want to have
2472  * the discussion displayed.
2473  *
2474  * @param int $id forum id if $forumtype is 'single',
2475  *              discussion id for any other forum type
2476  * @param mixed $mode forum layout mode
2477  * @param string $forumtype optional
2478  */
2479 function forum_print_mode_form($id, $mode, $forumtype='') {
2480     global $OUTPUT;
2481     if ($forumtype == 'single') {
2482         $select = new single_select(new moodle_url("/mod/forum/view.php", array('f'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
2483         $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
2484         $select->class = "forummode";
2485     } else {
2486         $select = new single_select(new moodle_url("/mod/forum/discuss.php", array('d'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
2487         $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
2488     }
2489     echo $OUTPUT->render($select);
2492 /**
2493  * @global object
2494  * @param object $course
2495  * @param string $search
2496  * @return string
2497  */
2498 function forum_search_form($course, $search='') {
2499     global $CFG, $PAGE;
2500     $forumsearch = new \mod_forum\output\quick_search_form($course->id, $search);
2501     $output = $PAGE->get_renderer('mod_forum');
2502     return $output->render($forumsearch);
2506 /**
2507  * @global object
2508  * @global object
2509  */
2510 function forum_set_return() {
2511     global $CFG, $SESSION;
2513     if (! isset($SESSION->fromdiscussion)) {
2514         $referer = get_local_referer(false);
2515         // If the referer is NOT a login screen then save it.
2516         if (! strncasecmp("$CFG->wwwroot/login", $referer, 300)) {
2517             $SESSION->fromdiscussion = $referer;
2518         }
2519     }
2523 /**
2524  * @global object
2525  * @param string|\moodle_url $default
2526  * @return string
2527  */
2528 function forum_go_back_to($default) {
2529     global $SESSION;
2531     if (!empty($SESSION->fromdiscussion)) {
2532         $returnto = $SESSION->fromdiscussion;
2533         unset($SESSION->fromdiscussion);
2534         return $returnto;
2535     } else {
2536         return $default;
2537     }
2540 /**
2541  * Given a discussion object that is being moved to $forumto,
2542  * this function checks all posts in that discussion
2543  * for attachments, and if any are found, these are
2544  * moved to the new forum directory.
2545  *
2546  * @global object
2547  * @param object $discussion
2548  * @param int $forumfrom source forum id
2549  * @param int $forumto target forum id
2550  * @return bool success
2551  */
2552 function forum_move_attachments($discussion, $forumfrom, $forumto) {
2553     global $DB;
2555     $fs = get_file_storage();
2557     $newcm = get_coursemodule_from_instance('forum', $forumto);
2558     $oldcm = get_coursemodule_from_instance('forum', $forumfrom);
2560     $newcontext = context_module::instance($newcm->id);
2561     $oldcontext = context_module::instance($oldcm->id);
2563     // loop through all posts, better not use attachment flag ;-)
2564     if ($posts = $DB->get_records('forum_posts', array('discussion'=>$discussion->id), '', 'id, attachment')) {
2565         foreach ($posts as $post) {
2566             $fs->move_area_files_to_new_context($oldcontext->id,
2567                     $newcontext->id, 'mod_forum', 'post', $post->id);
2568             $attachmentsmoved = $fs->move_area_files_to_new_context($oldcontext->id,
2569                     $newcontext->id, 'mod_forum', 'attachment', $post->id);
2570             if ($attachmentsmoved > 0 && $post->attachment != '1') {
2571                 // Weird - let's fix it
2572                 $post->attachment = '1';
2573                 $DB->update_record('forum_posts', $post);
2574             } else if ($attachmentsmoved == 0 && $post->attachment != '') {
2575                 // Weird - let's fix it
2576                 $post->attachment = '';
2577                 $DB->update_record('forum_posts', $post);
2578             }
2579         }
2580     }
2582     return true;
2585 /**
2586  * Returns attachments as formated text/html optionally with separate images
2587  *
2588  * @global object
2589  * @global object
2590  * @global object
2591  * @param object $post
2592  * @param object $cm
2593  * @param string $type html/text/separateimages
2594  * @return mixed string or array of (html text withouth images and image HTML)
2595  */
2596 function forum_print_attachments($post, $cm, $type) {
2597     global $CFG, $DB, $USER, $OUTPUT;
2599     if (empty($post->attachment)) {
2600         return $type !== 'separateimages' ? '' : array('', '');
2601     }
2603     if (!in_array($type, array('separateimages', 'html', 'text'))) {
2604         return $type !== 'separateimages' ? '' : array('', '');
2605     }
2607     if (!$context = context_module::instance($cm->id)) {
2608         return $type !== 'separateimages' ? '' : array('', '');
2609     }
2610     $strattachment = get_string('attachment', 'forum');
2612     $fs = get_file_storage();
2614     $imagereturn = '';
2615     $output = '';
2617     $canexport = !empty($CFG->enableportfolios) && (has_capability('mod/forum:exportpost', $context) || ($post->userid == $USER->id && has_capability('mod/forum:exportownpost', $context)));
2619     if ($canexport) {
2620         require_once($CFG->libdir.'/portfoliolib.php');
2621     }
2623     // We retrieve all files according to the time that they were created.  In the case that several files were uploaded
2624     // at the sametime (e.g. in the case of drag/drop upload) we revert to using the filename.
2625     $files = $fs->get_area_files($context->id, 'mod_forum', 'attachment', $post->id, "filename", false);
2626     if ($files) {
2627         if ($canexport) {
2628             $button = new portfolio_add_button();
2629         }
2630         foreach ($files as $file) {
2631             $filename = $file->get_filename();
2632             $mimetype = $file->get_mimetype();
2633             $iconimage = $OUTPUT->pix_icon(file_file_icon($file), get_mimetype_description($file), 'moodle', array('class' => 'icon'));
2634             $path = file_encode_url($CFG->wwwroot.'/pluginfile.php', '/'.$context->id.'/mod_forum/attachment/'.$post->id.'/'.$filename);
2636             if ($type == 'html') {
2637                 $output .= "<a href=\"$path\">$iconimage</a> ";
2638                 $output .= "<a href=\"$path\">".s($filename)."</a>";
2639                 if ($canexport) {
2640                     $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
2641                     $button->set_format_by_file($file);
2642                     $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
2643                 }
2644                 $output .= "<br />";
2646             } else if ($type == 'text') {
2647                 $output .= "$strattachment ".s($filename).":\n$path\n";
2649             } else { //'returnimages'
2650                 if (in_array($mimetype, array('image/gif', 'image/jpeg', 'image/png'))) {
2651                     // Image attachments don't get printed as links
2652                     $imagereturn .= "<br /><img src=\"$path\" alt=\"\" />";
2653                     if ($canexport) {
2654                         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
2655                         $button->set_format_by_file($file);
2656                         $imagereturn .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
2657                     }
2658                 } else {
2659                     $output .= "<a href=\"$path\">$iconimage</a> ";
2660                     $output .= format_text("<a href=\"$path\">".s($filename)."</a>", FORMAT_HTML, array('context'=>$context));
2661                     if ($canexport) {
2662                         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
2663                         $button->set_format_by_file($file);
2664                         $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
2665                     }
2666                     $output .= '<br />';
2667                 }
2668             }
2670             if (!empty($CFG->enableplagiarism)) {
2671                 require_once($CFG->libdir.'/plagiarismlib.php');
2672                 $output .= plagiarism_get_links(array('userid' => $post->userid,
2673                     'file' => $file,
2674                     'cmid' => $cm->id,
2675                     'course' => $cm->course,
2676                     'forum' => $cm->instance));
2677                 $output .= '<br />';
2678             }
2679         }
2680     }
2682     if ($type !== 'separateimages') {
2683         return $output;
2685     } else {
2686         return array($output, $imagereturn);
2687     }
2690 ////////////////////////////////////////////////////////////////////////////////
2691 // File API                                                                   //
2692 ////////////////////////////////////////////////////////////////////////////////
2694 /**
2695  * Lists all browsable file areas
2696  *
2697  * @package  mod_forum
2698  * @category files
2699  * @param stdClass $course course object
2700  * @param stdClass $cm course module object
2701  * @param stdClass $context context object
2702  * @return array
2703  */
2704 function forum_get_file_areas($course, $cm, $context) {
2705     return array(
2706         'attachment' => get_string('areaattachment', 'mod_forum'),
2707         'post' => get_string('areapost', 'mod_forum'),
2708     );
2711 /**
2712  * File browsing support for forum module.
2713  *
2714  * @package  mod_forum
2715  * @category files
2716  * @param stdClass $browser file browser object
2717  * @param stdClass $areas file areas
2718  * @param stdClass $course course object
2719  * @param stdClass $cm course module
2720  * @param stdClass $context context module
2721  * @param string $filearea file area
2722  * @param int $itemid item ID
2723  * @param string $filepath file path
2724  * @param string $filename file name
2725  * @return file_info instance or null if not found
2726  */
2727 function forum_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
2728     global $CFG, $DB, $USER;
2730     if ($context->contextlevel != CONTEXT_MODULE) {
2731         return null;
2732     }
2734     // filearea must contain a real area
2735     if (!isset($areas[$filearea])) {
2736         return null;
2737     }
2739     // Note that forum_user_can_see_post() additionally allows access for parent roles
2740     // and it explicitly checks qanda forum type, too. One day, when we stop requiring
2741     // course:managefiles, we will need to extend this.
2742     if (!has_capability('mod/forum:viewdiscussion', $context)) {
2743         return null;
2744     }
2746     if (is_null($itemid)) {
2747         require_once($CFG->dirroot.'/mod/forum/locallib.php');
2748         return new forum_file_info_container($browser, $course, $cm, $context, $areas, $filearea);
2749     }
2751     static $cached = array();
2752     // $cached will store last retrieved post, discussion and forum. To make sure that the cache
2753     // is cleared between unit tests we check if this is the same session
2754     if (!isset($cached['sesskey']) || $cached['sesskey'] != sesskey()) {
2755         $cached = array('sesskey' => sesskey());
2756     }
2758     if (isset($cached['post']) && $cached['post']->id == $itemid) {
2759         $post = $cached['post'];
2760     } else if ($post = $DB->get_record('forum_posts', array('id' => $itemid))) {
2761         $cached['post'] = $post;
2762     } else {
2763         return null;
2764     }
2766     if (isset($cached['discussion']) && $cached['discussion']->id == $post->discussion) {
2767         $discussion = $cached['discussion'];
2768     } else if ($discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion))) {
2769         $cached['discussion'] = $discussion;
2770     } else {
2771         return null;
2772     }
2774     if (isset($cached['forum']) && $cached['forum']->id == $cm->instance) {
2775         $forum = $cached['forum'];
2776     } else if ($forum = $DB->get_record('forum', array('id' => $cm->instance))) {
2777         $cached['forum'] = $forum;
2778     } else {
2779         return null;
2780     }
2782     $fs = get_file_storage();
2783     $filepath = is_null($filepath) ? '/' : $filepath;
2784     $filename = is_null($filename) ? '.' : $filename;
2785     if (!($storedfile = $fs->get_file($context->id, 'mod_forum', $filearea, $itemid, $filepath, $filename))) {
2786         return null;
2787     }
2789     // Checks to see if the user can manage files or is the owner.
2790     // TODO MDL-33805 - Do not use userid here and move the capability check above.
2791     if (!has_capability('moodle/course:managefiles', $context) && $storedfile->get_userid() != $USER->id) {
2792         return null;
2793     }
2794     // Make sure groups allow this user to see this file
2795     if ($discussion->groupid > 0 && !has_capability('moodle/site:accessallgroups', $context)) {
2796         $groupmode = groups_get_activity_groupmode($cm, $course);
2797         if ($groupmode == SEPARATEGROUPS && !groups_is_member($discussion->groupid)) {
2798             return null;
2799         }
2800     }
2802     // Make sure we're allowed to see it...
2803     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
2804         return null;
2805     }
2807     $urlbase = $CFG->wwwroot.'/pluginfile.php';
2808     return new file_info_stored($browser, $context, $storedfile, $urlbase, $itemid, true, true, false, false);
2811 /**
2812  * Serves the forum attachments. Implements needed access control ;-)
2813  *
2814  * @package  mod_forum
2815  * @category files
2816  * @param stdClass $course course object
2817  * @param stdClass $cm course module object
2818  * @param stdClass $context context object
2819  * @param string $filearea file area
2820  * @param array $args extra arguments
2821  * @param bool $forcedownload whether or not force download
2822  * @param array $options additional options affecting the file serving
2823  * @return bool false if file not found, does not return if found - justsend the file
2824  */
2825 function forum_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
2826     global $CFG, $DB;
2828     if ($context->contextlevel != CONTEXT_MODULE) {
2829         return false;
2830     }
2832     require_course_login($course, true, $cm);
2834     $areas = forum_get_file_areas($course, $cm, $context);
2836     // filearea must contain a real area
2837     if (!isset($areas[$filearea])) {
2838         return false;
2839     }
2841     $postid = (int)array_shift($args);
2843     if (!$post = $DB->get_record('forum_posts', array('id'=>$postid))) {
2844         return false;
2845     }
2847     if (!$discussion = $DB->get_record('forum_discussions', array('id'=>$post->discussion))) {
2848         return false;
2849     }
2851     if (!$forum = $DB->get_record('forum', array('id'=>$cm->instance))) {
2852         return false;
2853     }
2855     $fs = get_file_storage();
2856     $relativepath = implode('/', $args);
2857     $fullpath = "/$context->id/mod_forum/$filearea/$postid/$relativepath";
2858     if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
2859         return false;
2860     }
2862     // Make sure groups allow this user to see this file
2863     if ($discussion->groupid > 0) {
2864         $groupmode = groups_get_activity_groupmode($cm, $course);
2865         if ($groupmode == SEPARATEGROUPS) {
2866             if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
2867                 return false;
2868             }
2869         }
2870     }
2872     // Make sure we're allowed to see it...
2873     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
2874         return false;
2875     }
2877     // finally send the file
2878     send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
2881 /**
2882  * If successful, this function returns the name of the file
2883  *
2884  * @global object
2885  * @param object $post is a full post record, including course and forum
2886  * @param object $forum
2887  * @param object $cm
2888  * @param mixed $mform
2889  * @param string $unused
2890  * @return bool
2891  */
2892 function forum_add_attachment($post, $forum, $cm, $mform=null, $unused=null) {
2893     global $DB;
2895     if (empty($mform)) {
2896         return false;
2897     }
2899     if (empty($post->attachments)) {
2900         return true;   // Nothing to do
2901     }
2903     $context = context_module::instance($cm->id);
2905     $info = file_get_draft_area_info($post->attachments);
2906     $present = ($info['filecount']>0) ? '1' : '';
2907     file_save_draft_area_files($post->attachments, $context->id, 'mod_forum', 'attachment', $post->id,
2908             mod_forum_post_form::attachment_options($forum));
2910     $DB->set_field('forum_posts', 'attachment', $present, array('id'=>$post->id));
2912     return true;
2915 /**
2916  * Add a new post in an existing discussion.
2917  *
2918  * @param   stdClass    $post       The post data
2919  * @param   mixed       $mform      The submitted form
2920  * @param   string      $unused
2921  * @return int
2922  */
2923 function forum_add_new_post($post, $mform, $unused = null) {
2924     global $USER, $DB;
2926     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion));
2927     $forum      = $DB->get_record('forum', array('id' => $discussion->forum));
2928     $cm         = get_coursemodule_from_instance('forum', $forum->id);
2929     $context    = context_module::instance($cm->id);
2930     $privatereplyto = 0;
2932     // Check whether private replies should be enabled for this post.
2933     if ($post->parent) {
2934         $parent = $DB->get_record('forum_posts', array('id' => $post->parent));
2936         if (!empty($parent->privatereplyto)) {
2937             throw new \coding_exception('It should not be possible to reply to a private reply');
2938         }
2940         if (!empty($post->isprivatereply) && forum_user_can_reply_privately($context, $parent)) {
2941             $privatereplyto = $parent->userid;
2942         }
2943     }
2945     $post->created    = $post->modified = time();
2946     $post->mailed     = FORUM_MAILED_PENDING;
2947     $post->userid     = $USER->id;
2948     $post->privatereplyto = $privatereplyto;
2949     $post->attachment = "";
2950     if (!isset($post->totalscore)) {
2951         $post->totalscore = 0;
2952     }
2953     if (!isset($post->mailnow)) {
2954         $post->mailnow    = 0;
2955     }
2957     $post->id = $DB->insert_record("forum_posts", $post);
2958     $post->message = file_save_draft_area_files($post->itemid, $context->id, 'mod_forum', 'post', $post->id,
2959             mod_forum_post_form::editor_options($context, null), $post->message);
2960     $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
2961     forum_add_attachment($post, $forum, $cm, $mform);
2963     // Update discussion modified date
2964     $DB->set_field("forum_discussions", "timemodified", $post->modified, array("id" => $post->discussion));
2965     $DB->set_field("forum_discussions", "usermodified", $post->userid, array("id" => $post->discussion));
2967     if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
2968         forum_tp_mark_post_read($post->userid, $post);
2969     }
2971     if (isset($post->tags)) {
2972         core_tag_tag::set_item_tags('mod_forum', 'forum_posts', $post->id, $context, $post->tags);
2973     }
2975     // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
2976     forum_trigger_content_uploaded_event($post, $cm, 'forum_add_new_post');
2978     return $post->id;
2981 /**
2982  * Update a post.
2983  *
2984  * @param   stdClass    $newpost    The post to update
2985  * @param   mixed       $mform      The submitted form
2986  * @param   string      $unused
2987  * @return  bool
2988  */
2989 function forum_update_post($newpost, $mform, $unused = null) {
2990     global $DB, $USER;
2992     $post       = $DB->get_record('forum_posts', array('id' => $newpost->id));
2993     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion));
2994     $forum      = $DB->get_record('forum', array('id' => $discussion->forum));
2995     $cm         = get_coursemodule_from_instance('forum', $forum->id);
2996     $context    = context_module::instance($cm->id);
2998     // Allowed modifiable fields.
2999     $modifiablefields = [
3000         'subject',
3001         'message',
3002         'messageformat',
3003         'messagetrust',
3004         'timestart',
3005         'timeend',
3006         'pinned',
3007         'attachments',
3008     ];
3009     foreach ($modifiablefields as $field) {
3010         if (isset($newpost->{$field})) {
3011             $post->{$field} = $newpost->{$field};
3012         }
3013     }
3014     $post->modified = time();
3016     if (!$post->parent) {   // Post is a discussion starter - update discussion title and times too
3017         $discussion->name      = $post->subject;
3018         $discussion->timestart = $post->timestart;
3019         $discussion->timeend   = $post->timeend;
3021         if (isset($post->pinned)) {
3022             $discussion->pinned = $post->pinned;
3023         }
3024     }
3025     $post->message = file_save_draft_area_files($newpost->itemid, $context->id, 'mod_forum', 'post', $post->id,
3026             mod_forum_post_form::editor_options($context, $post->id), $post->message);
3027     $DB->update_record('forum_posts', $post);
3028     // Note: Discussion modified time/user are intentionally not updated, to enable them to track the latest new post.
3029     $DB->update_record('forum_discussions', $discussion);
3031     forum_add_attachment($post, $forum, $cm, $mform);
3033     if (isset($newpost->tags)) {
3034         core_tag_tag::set_item_tags('mod_forum', 'forum_posts', $post->id, $context, $newpost->tags);
3035     }
3037     if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
3038         forum_tp_mark_post_read($USER->id, $post);
3039     }
3041     // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
3042     forum_trigger_content_uploaded_event($post, $cm, 'forum_update_post');
3044     return true;
3047 /**
3048  * Given an object containing all the necessary data,
3049  * create a new discussion and return the id
3050  *
3051  * @param object $post
3052  * @param mixed $mform
3053  * @param string $unused
3054  * @param int $userid
3055  * @return object
3056  */
3057 function forum_add_discussion($discussion, $mform=null, $unused=null, $userid=null) {
3058     global $USER, $CFG, $DB;
3060     $timenow = isset($discussion->timenow) ? $discussion->timenow : time();
3062     if (is_null($userid)) {
3063         $userid = $USER->id;
3064     }
3066     // The first post is stored as a real post, and linked
3067     // to from the discuss entry.
3069     $forum = $DB->get_record('forum', array('id'=>$discussion->forum));
3070     $cm    = get_coursemodule_from_instance('forum', $forum->id);
3072     $post = new stdClass();
3073     $post->discussion    = 0;
3074     $post->parent        = 0;
3075     $post->privatereplyto = 0;
3076     $post->userid        = $userid;
3077     $post->created       = $timenow;
3078     $post->modified      = $timenow;
3079     $post->mailed        = FORUM_MAILED_PENDING;
3080     $post->subject       = $discussion->name;
3081     $post->message       = $discussion->message;
3082     $post->messageformat = $discussion->messageformat;
3083     $post->messagetrust  = $discussion->messagetrust;
3084     $post->attachments   = isset($discussion->attachments) ? $discussion->attachments : null;
3085     $post->forum         = $forum->id;     // speedup
3086     $post->course        = $forum->course; // speedup
3087     $post->mailnow       = $discussion->mailnow;
3089     $post->id = $DB->insert_record("forum_posts", $post);
3091     // TODO: Fix the calling code so that there always is a $cm when this function is called
3092     if (!empty($cm->id) && !empty($discussion->itemid)) {   // In "single simple discussions" this may not exist yet
3093         $context = context_module::instance($cm->id);
3094         $text = file_save_draft_area_files($discussion->itemid, $context->id, 'mod_forum', 'post', $post->id,
3095                 mod_forum_post_form::editor_options($context, null), $post->message);
3096         $DB->set_field('forum_posts', 'message', $text, array('id'=>$post->id));
3097     }
3099     // Now do the main entry for the discussion, linking to this first post
3101     $discussion->firstpost    = $post->id;
3102     $discussion->timemodified = $timenow;
3103     $discussion->usermodified = $post->userid;
3104     $discussion->userid       = $userid;
3105     $discussion->assessed     = 0;
3107     $post->discussion = $DB->insert_record("forum_discussions", $discussion);
3109     // Finally, set the pointer on the post.
3110     $DB->set_field("forum_posts", "discussion", $post->discussion, array("id"=>$post->id));
3112     if (!empty($cm->id)) {
3113         forum_add_attachment($post, $forum, $cm, $mform, $unused);
3114     }
3116     if (isset($discussion->tags)) {
3117         core_tag_tag::set_item_tags('mod_forum', 'forum_posts', $post->id, context_module::instance($cm->id), $discussion->tags);
3118     }
3120     if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
3121         forum_tp_mark_post_read($post->userid, $post);
3122     }
3124     // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
3125     if (!empty($cm->id)) {
3126         forum_trigger_content_uploaded_event($post, $cm, 'forum_add_discussion');
3127     }
3129     return $post->discussion;
3133 /**
3134  * Deletes a discussion and handles all associated cleanup.
3135  *
3136  * @global object
3137  * @param object $discussion Discussion to delete
3138  * @param bool $fulldelete True when deleting entire forum
3139  * @param object $course Course
3140  * @param object $cm Course-module
3141  * @param object $forum Forum
3142  * @return bool
3143  */
3144 function forum_delete_discussion($discussion, $fulldelete, $course, $cm, $forum) {
3145     global $DB, $CFG;
3146     require_once($CFG->libdir.'/completionlib.php');
3148     $result = true;
3150     if ($posts = $DB->get_records("forum_posts", array("discussion" => $discussion->id))) {
3151         foreach ($posts as $post) {
3152             $post->course = $discussion->course;
3153             $post->forum  = $discussion->forum;
3154             if (!forum_delete_post($post, 'ignore', $course, $cm, $forum, $fulldelete)) {
3155                 $result = false;
3156             }
3157         }
3158     }
3160     forum_tp_delete_read_records(-1, -1, $discussion->id);
3162     // Discussion subscriptions must be removed before discussions because of key constraints.
3163     $DB->delete_records('forum_discussion_subs', array('discussion' => $discussion->id));
3164     if (!$DB->delete_records("forum_discussions", array("id" => $discussion->id))) {
3165         $result = false;
3166     }
3168     // Update completion state if we are tracking completion based on number of posts
3169     // But don't bother when deleting whole thing
3170     if (!$fulldelete) {
3171         $completion = new completion_info($course);
3172         if ($completion->is_enabled($cm) == COMPLETION_TRACKING_AUTOMATIC &&
3173            ($forum->completiondiscussions || $forum->completionreplies || $forum->completionposts)) {
3174             $completion->update_state($cm, COMPLETION_INCOMPLETE, $discussion->userid);
3175         }
3176     }
3178     return $result;
3182 /**
3183  * Deletes a single forum post.
3184  *
3185  * @global object
3186  * @param object $post Forum post object
3187  * @param mixed $children Whether to delete children. If false, returns false
3188  *   if there are any children (without deleting the post). If true,
3189  *   recursively deletes all children. If set to special value 'ignore', deletes
3190  *   post regardless of children (this is for use only when deleting all posts
3191  *   in a disussion).
3192  * @param object $course Course
3193  * @param object $cm Course-module
3194  * @param object $forum Forum
3195  * @param bool $skipcompletion True to skip updating completion state if it
3196  *   would otherwise be updated, i.e. when deleting entire forum anyway.
3197  * @return bool
3198  */
3199 function forum_delete_post($post, $children, $course, $cm, $forum, $skipcompletion=false) {
3200     global $DB, $CFG, $USER;
3201     require_once($CFG->libdir.'/completionlib.php');
3203     $context = context_module::instance($cm->id);
3205     if ($children !== 'ignore' && ($childposts = $DB->get_records('forum_posts', array('parent'=>$post->id)))) {
3206        if ($children) {
3207            foreach ($childposts as $childpost) {
3208                forum_delete_post($childpost, true, $course, $cm, $forum, $skipcompletion);
3209            }
3210        } else {
3211            return false;
3212        }
3213     }
3215     // Delete ratings.
3216     require_once($CFG->dirroot.'/rating/lib.php');
3217     $delopt = new stdClass;
3218     $delopt->contextid = $context->id;
3219     $delopt->component = 'mod_forum';
3220     $delopt->ratingarea = 'post';
3221     $delopt->itemid = $post->id;
3222     $rm = new rating_manager();
3223     $rm->delete_ratings($delopt);
3225     // Delete attachments.
3226     $fs = get_file_storage();
3227     $fs->delete_area_files($context->id, 'mod_forum', 'attachment', $post->id);
3228     $fs->delete_area_files($context->id, 'mod_forum', 'post', $post->id);
3230     // Delete cached RSS feeds.
3231     if (!empty($CFG->enablerssfeeds)) {
3232         require_once($CFG->dirroot.'/mod/forum/rsslib.php');
3233         forum_rss_delete_file($forum);
3234     }
3236     if ($DB->delete_records("forum_posts", array("id" => $post->id))) {
3238         forum_tp_delete_read_records(-1, $post->id);
3240     // Just in case we are deleting the last post
3241         forum_discussion_update_last_post($post->discussion);
3243         // Update completion state if we are tracking completion based on number of posts
3244         // But don't bother when deleting whole thing
3246         if (!$skipcompletion) {
3247             $completion = new completion_info($course);
3248             if ($completion->is_enabled($cm) == COMPLETION_TRACKING_AUTOMATIC &&
3249                ($forum->completiondiscussions || $forum->completionreplies || $forum->completionposts)) {
3250                 $completion->update_state($cm, COMPLETION_INCOMPLETE, $post->userid);
3251             }
3252         }
3254         $params = array(
3255             'context' => $context,
3256             'objectid' => $post->id,
3257             'other' => array(
3258                 'discussionid' => $post->discussion,
3259                 'forumid' => $forum->id,
3260                 'forumtype' => $forum->type,
3261             )
3262         );
3263         $post->deleted = 1;
3264         if ($post->userid !== $USER->id) {
3265             $params['relateduserid'] = $post->userid;
3266         }
3267         $event = \mod_forum\event\post_deleted::create($params);
3268         $event->add_record_snapshot('forum_posts', $post);
3269         $event->trigger();
3271         return true;
3272     }
3273     return false;
3276 /**
3277  * Sends post content to plagiarism plugin
3278  * @param object $post Forum post object
3279  * @param object $cm Course-module
3280  * @param string $name
3281  * @return bool
3282 */
3283 function forum_trigger_content_uploaded_event($post, $cm, $name) {
3284     $context = context_module::instance($cm->id);
3285     $fs = get_file_storage();
3286     $files = $fs->get_area_files($context->id, 'mod_forum', 'attachment', $post->id, "timemodified", false);
3287     $params = array(
3288         'context' => $context,
3289         'objectid' => $post->id,
3290         'other' => array(
3291             'content' => $post->message,
3292             'pathnamehashes' => array_keys($files),
3293             'discussionid' => $post->discussion,
3294             'triggeredfrom' => $name,
3295         )
3296     );
3297     $event = \mod_forum\event\assessable_uploaded::create($params);
3298     $event->trigger();
3299     return true;
3302 /**
3303  * Given a new post, subscribes or unsubscribes as appropriate.
3304  * Returns some text which describes what happened.
3305  *
3306  * @param object $fromform The submitted form
3307  * @param stdClass $forum The forum record
3308  * @param stdClass $discussion The forum discussion record
3309  * @return string
3310  */
3311 function forum_post_subscription($fromform, $forum, $discussion) {
3312     global $USER;
3314     if (\mod_forum\subscriptions::is_forcesubscribed($forum)) {
3315         return "";
3316     } else if (\mod_forum\subscriptions::subscription_disabled($forum)) {
3317         $subscribed = \mod_forum\subscriptions::is_subscribed($USER->id, $forum);
3318         if ($subscribed && !has_capability('moodle/course:manageactivities', context_course::instance($forum->course), $USER->id)) {
3319             // This user should not be subscribed to the forum.
3320             \mod_forum\subscriptions::unsubscribe_user($USER->id, $forum);
3321         }
3322         return "";
3323     }
3325     $info = new stdClass();
3326     $info->name  = fullname($USER);
3327     $info->discussion = format_string($discussion->name);
3328     $info->forum = format_string($forum->name);
3330     if (isset($fromform->discussionsubscribe) && $fromform->discussionsubscribe) {
3331         if ($result = \mod_forum\subscriptions::subscribe_user_to_discussion($USER->id, $discussion)) {
3332             return html_writer::tag('p', get_string('discussionnowsubscribed', 'forum', $info));
3333         }
3334     } else {
3335         if ($result = \mod_forum\subscriptions::unsubscribe_user_from_discussion($USER->id, $discussion)) {
3336             return html_writer::tag('p', get_string('discussionnownotsubscribed', 'forum', $info));
3337         }
3338     }
3340     return '';
3343 /**
3344  * Generate and return the subscribe or unsubscribe link for a forum.
3345  *
3346  * @param object $forum the forum. Fields used are $forum->id and $forum->forcesubscribe.
3347  * @param object $context the context object for this forum.
3348  * @param array $messages text used for the link in its various states
3349  *      (subscribed, unsubscribed, forcesubscribed or cantsubscribe).
3350  *      Any strings not passed in are taken from the $defaultmessages array
3351  *      at the top of the function.
3352  * @param bool $cantaccessagroup
3353  * @param bool $unused1
3354  * @param bool $backtoindex
3355  * @param array $unused2
3356  * @return string
3357  */
3358 function forum_get_subscribe_link($forum, $context, $messages = array(), $cantaccessagroup = false, $unused1 = true,
3359     $backtoindex = false, $unused2 = null) {
3360     global $CFG, $USER, $PAGE, $OUTPUT;
3361     $defaultmessages = array(
3362         'subscribed' => get_string('unsubscribe', 'forum'),
3363         'unsubscribed' => get_string('subscribe', 'forum'),
3364         'cantaccessgroup' => get_string('no'),
3365         'forcesubscribed' => get_string('everyoneissubscribed', 'forum'),
3366         'cantsubscribe' => get_string('disallowsubscribe','forum')
3367     );
3368     $messages = $messages + $defaultmessages;
3370     if (\mod_forum\subscriptions::is_forcesubscribed($forum)) {
3371         return $messages['forcesubscribed'];
3372     } else if (\mod_forum\subscriptions::subscription_disabled($forum) &&
3373             !has_capability('mod/forum:managesubscriptions', $context)) {
3374         return $messages['cantsubscribe'];
3375     } else if ($cantaccessagroup) {
3376         return $messages['cantaccessgroup'];
3377     } else {
3378         if (!is_enrolled($context, $USER, '', true)) {
3379             return '';
3380         }
3382         $subscribed = \mod_forum\subscriptions::is_subscribed($USER->id, $forum);
3383         if ($subscribed) {
3384             $linktext = $messages['subscribed'];
3385             $linktitle = get_string('subscribestop', 'forum');
3386         } else {
3387             $linktext = $messages['unsubscribed'];
3388             $linktitle = get_string('subscribestart', 'forum');
3389         }
3391         $options = array();
3392         if ($backtoindex) {
3393             $backtoindexlink = '&amp;backtoindex=1';
3394             $options['backtoindex'] = 1;
3395         } else {
3396             $backtoindexlink = '';
3397         }
3399         $options['id'] = $forum->id;
3400         $options['sesskey'] = sesskey();
3401         $url = new moodle_url('/mod/forum/subscribe.php', $options);
3402         return $OUTPUT->single_button($url, $linktext, 'get', array('title' => $linktitle));
3403     }
3406 /**
3407  * Returns true if user created new discussion already.
3408  *
3409  * @param int $forumid  The forum to check for postings
3410  * @param int $userid   The user to check for postings
3411  * @param int $groupid  The group to restrict the check to
3412  * @return bool
3413  */
3414 function forum_user_has_posted_discussion($forumid, $userid, $groupid = null) {
3415     global $CFG, $DB;
3417     $sql = "SELECT 'x'
3418               FROM {forum_discussions} d, {forum_posts} p
3419              WHERE d.forum = ? AND p.discussion = d.id AND p.parent = 0 AND p.userid = ?";
3421     $params = [$forumid, $userid];
3423     if ($groupid) {
3424         $sql .= " AND d.groupid = ?";
3425         $params[] = $groupid;
3426     }
3428     return $DB->record_exists_sql($sql, $params);
3431 /**
3432  * @global object
3433  * @global object
3434  * @param int $forumid
3435  * @param int $userid
3436  * @return array
3437  */
3438 function forum_discussions_user_has_posted_in($forumid, $userid) {
3439     global $CFG, $DB;
3441     $haspostedsql = "SELECT d.id AS id,
3442                             d.*
3443                        FROM {forum_posts} p,
3444                             {forum_discussions} d
3445                       WHERE p.discussion = d.id
3446                         AND d.forum = ?
3447                         AND p.userid = ?";
3449     return $DB->get_records_sql($haspostedsql, array($forumid, $userid));
3452 /**
3453  * @global object
3454  * @global object
3455  * @param int $forumid
3456  * @param int $did
3457  * @param int $userid
3458  * @return bool
3459  */
3460 function forum_user_has_posted($forumid, $did, $userid) {
3461     global $DB;
3463     if (empty($did)) {
3464         // posted in any forum discussion?
3465         $sql = "SELECT 'x'
3466                   FROM {forum_posts} p
3467                   JOIN {forum_discussions} d ON d.id = p.discussion
3468                  WHERE p.userid = :userid AND d.forum = :forumid";
3469         return $DB->record_exists_sql($sql, array('forumid'=>$forumid,'userid'=>$userid));
3470     } else {
3471         return $DB->record_exists('forum_posts', array('discussion'=>$did,'userid'=>$userid));
3472     }
3475 /**
3476  * Returns creation time of the first user's post in given discussion
3477  * @global object $DB
3478  * @param int $did Discussion id
3479  * @param int $userid User id
3480  * @return int|bool post creation time stamp or return false
3481  */
3482 function forum_get_user_posted_time($did, $userid) {
3483     global $DB;
3485     $posttime = $DB->get_field('forum_posts', 'MIN(created)', array('userid'=>$userid, 'discussion'=>$did));
3486     if (empty($posttime)) {
3487         return false;
3488     }
3489     return $posttime;
3492 /**
3493  * @global object
3494  * @param object $forum
3495  * @param object $currentgroup
3496  * @param int $unused
3497  * @param object $cm
3498  * @param object $context
3499  * @return bool
3500  */
3501 function forum_user_can_post_discussion($forum, $currentgroup=null, $unused=-1, $cm=NULL, $context=NULL) {
3502 // $forum is an object
3503     global $USER;
3505     // shortcut - guest and not-logged-in users can not post
3506     if (isguestuser() or !isloggedin()) {
3507         return false;
3508     }
3510     if (!$cm) {
3511         debugging('missing cm', DEBUG_DEVELOPER);
3512         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
3513             print_error('invalidcoursemodule');
3514         }
3515     }
3517     if (!$context) {
3518         $context = context_module::instance($cm->id);
3519     }
3521     if (forum_is_cutoff_date_reached($forum)) {
3522         if (!has_capability('mod/forum:canoverridecutoff', $context)) {
3523             return false;
3524         }
3525     }
3527     if ($currentgroup === null) {
3528         $currentgroup = groups_get_activity_group($cm);
3529     }
3531     $groupmode = groups_get_activity_groupmode($cm);
3533     if ($forum->type == 'news') {
3534         $capname = 'mod/forum:addnews';
3535     } else if ($forum->type == 'qanda') {
3536         $capname = 'mod/forum:addquestion';
3537     } else {
3538         $capname = 'mod/forum:startdiscussion';
3539     }
3541     if (!has_capability($capname, $context)) {
3542         return false;
3543     }
3545     if ($forum->type == 'single') {
3546         return false;
3547     }
3549     if ($forum->type == 'eachuser') {
3550         if (forum_user_has_posted_discussion($forum->id, $USER->id, $currentgroup)) {
3551             return false;
3552         }
3553     }
3555     if (!$groupmode or has_capability('moodle/site:accessallgroups', $context)) {
3556         return true;
3557     }
3559     if ($currentgroup) {
3560         return groups_is_member($currentgroup);
3561     } else {
3562         // no group membership and no accessallgroups means no new discussions
3563         // reverted to 1.7 behaviour in 1.9+,  buggy in 1.8.0-1.9.0
3564         return false;
3565     }
3568 /**
3569  * This function checks whether the user can reply to posts in a forum
3570  * discussion. Use forum_user_can_post_discussion() to check whether the user
3571  * can start discussions.
3572  *
3573  * @global object
3574  * @global object
3575  * @uses DEBUG_DEVELOPER
3576  * @uses CONTEXT_MODULE
3577  * @uses VISIBLEGROUPS
3578  * @param object $forum forum object
3579  * @param object $discussion
3580  * @param object $user
3581  * @param object $cm
3582  * @param object $course
3583  * @param object $context
3584  * @return bool
3585  */
3586 function forum_user_can_post($forum, $discussion, $user=NULL, $cm=NULL, $course=NULL, $context=NULL) {
3587     global $USER, $DB;
3588     if (empty($user)) {
3589         $user = $USER;
3590     }
3592     // shortcut - guest and not-logged-in users can not post
3593     if (isguestuser($user) or empty($user->id)) {
3594         return false;
3595     }
3597     if (!isset($discussion->groupid)) {
3598         debugging('incorrect discussion parameter', DEBUG_DEVELOPER);
3599         return false;
3600     }
3602     if (!$cm) {
3603         debugging('missing cm', DEBUG_DEVELOPER);
3604         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
3605             print_error('invalidcoursemodule');
3606         }
3607     }
3609     if (!$course) {
3610         debugging('missing course', DEBUG_DEVELOPER);
3611         if (!$course = $DB->get_record('course', array('id' => $forum->course))) {
3612             print_error('invalidcourseid');
3613         }
3614     }
3616     if (!$context) {
3617         $context = context_module::instance($cm->id);
3618     }
3620     if (forum_is_cutoff_date_reached($forum)) {
3621         if (!has_capability('mod/forum:canoverridecutoff', $context)) {
3622             return false;
3623         }
3624     }
3626     // Check whether the discussion is locked.