weekly release 3.7dev
[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     $forum->timemodified = time();
91     if (empty($forum->assessed)) {
92         $forum->assessed = 0;
93     }
95     if (empty($forum->ratingtime) or empty($forum->assessed)) {
96         $forum->assesstimestart  = 0;
97         $forum->assesstimefinish = 0;
98     }
100     $forum->id = $DB->insert_record('forum', $forum);
101     $modcontext = context_module::instance($forum->coursemodule);
103     if ($forum->type == 'single') {  // Create related discussion.
104         $discussion = new stdClass();
105         $discussion->course        = $forum->course;
106         $discussion->forum         = $forum->id;
107         $discussion->name          = $forum->name;
108         $discussion->assessed      = $forum->assessed;
109         $discussion->message       = $forum->intro;
110         $discussion->messageformat = $forum->introformat;
111         $discussion->messagetrust  = trusttext_trusted(context_course::instance($forum->course));
112         $discussion->mailnow       = false;
113         $discussion->groupid       = -1;
115         $message = '';
117         $discussion->id = forum_add_discussion($discussion, null, $message);
119         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
120             // Ugly hack - we need to copy the files somehow.
121             $discussion = $DB->get_record('forum_discussions', array('id'=>$discussion->id), '*', MUST_EXIST);
122             $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
124             $options = array('subdirs'=>true); // Use the same options as intro field!
125             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
126             $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
127         }
128     }
130     forum_grade_item_update($forum);
132     $completiontimeexpected = !empty($forum->completionexpected) ? $forum->completionexpected : null;
133     \core_completion\api::update_completion_date_event($forum->coursemodule, 'forum', $forum->id, $completiontimeexpected);
135     return $forum->id;
138 /**
139  * Handle changes following the creation of a forum instance.
140  * This function is typically called by the course_module_created observer.
141  *
142  * @param object $context the forum context
143  * @param stdClass $forum The forum object
144  * @return void
145  */
146 function forum_instance_created($context, $forum) {
147     if ($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) {
148         $users = \mod_forum\subscriptions::get_potential_subscribers($context, 0, 'u.id, u.email');
149         foreach ($users as $user) {
150             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $context);
151         }
152     }
155 /**
156  * Given an object containing all the necessary data,
157  * (defined by the form in mod_form.php) this function
158  * will update an existing instance with new data.
159  *
160  * @global object
161  * @param object $forum forum instance (with magic quotes)
162  * @return bool success
163  */
164 function forum_update_instance($forum, $mform) {
165     global $DB, $OUTPUT, $USER;
167     $forum->timemodified = time();
168     $forum->id           = $forum->instance;
170     if (empty($forum->assessed)) {
171         $forum->assessed = 0;
172     }
174     if (empty($forum->ratingtime) or empty($forum->assessed)) {
175         $forum->assesstimestart  = 0;
176         $forum->assesstimefinish = 0;
177     }
179     $oldforum = $DB->get_record('forum', array('id'=>$forum->id));
181     // MDL-3942 - if the aggregation type or scale (i.e. max grade) changes then recalculate the grades for the entire forum
182     // if  scale changes - do we need to recheck the ratings, if ratings higher than scale how do we want to respond?
183     // 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
184     if (($oldforum->assessed<>$forum->assessed) or ($oldforum->scale<>$forum->scale)) {
185         forum_update_grades($forum); // recalculate grades for the forum
186     }
188     if ($forum->type == 'single') {  // Update related discussion and post.
189         $discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id), 'timemodified ASC');
190         if (!empty($discussions)) {
191             if (count($discussions) > 1) {
192                 echo $OUTPUT->notification(get_string('warnformorepost', 'forum'));
193             }
194             $discussion = array_pop($discussions);
195         } else {
196             // try to recover by creating initial discussion - MDL-16262
197             $discussion = new stdClass();
198             $discussion->course          = $forum->course;
199             $discussion->forum           = $forum->id;
200             $discussion->name            = $forum->name;
201             $discussion->assessed        = $forum->assessed;
202             $discussion->message         = $forum->intro;
203             $discussion->messageformat   = $forum->introformat;
204             $discussion->messagetrust    = true;
205             $discussion->mailnow         = false;
206             $discussion->groupid         = -1;
208             $message = '';
210             forum_add_discussion($discussion, null, $message);
212             if (! $discussion = $DB->get_record('forum_discussions', array('forum'=>$forum->id))) {
213                 print_error('cannotadd', 'forum');
214             }
215         }
216         if (! $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost))) {
217             print_error('cannotfindfirstpost', 'forum');
218         }
220         $cm         = get_coursemodule_from_instance('forum', $forum->id);
221         $modcontext = context_module::instance($cm->id, MUST_EXIST);
223         $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
224         $post->subject       = $forum->name;
225         $post->message       = $forum->intro;
226         $post->messageformat = $forum->introformat;
227         $post->messagetrust  = trusttext_trusted($modcontext);
228         $post->modified      = $forum->timemodified;
229         $post->userid        = $USER->id;    // MDL-18599, so that current teacher can take ownership of activities.
231         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
232             // Ugly hack - we need to copy the files somehow.
233             $options = array('subdirs'=>true); // Use the same options as intro field!
234             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
235         }
237         $DB->update_record('forum_posts', $post);
238         $discussion->name = $forum->name;
239         $DB->update_record('forum_discussions', $discussion);
240     }
242     $DB->update_record('forum', $forum);
244     $modcontext = context_module::instance($forum->coursemodule);
245     if (($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) && ($oldforum->forcesubscribe <> $forum->forcesubscribe)) {
246         $users = \mod_forum\subscriptions::get_potential_subscribers($modcontext, 0, 'u.id, u.email', '');
247         foreach ($users as $user) {
248             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $modcontext);
249         }
250     }
252     forum_grade_item_update($forum);
254     $completiontimeexpected = !empty($forum->completionexpected) ? $forum->completionexpected : null;
255     \core_completion\api::update_completion_date_event($forum->coursemodule, 'forum', $forum->id, $completiontimeexpected);
257     return true;
261 /**
262  * Given an ID of an instance of this module,
263  * this function will permanently delete the instance
264  * and any data that depends on it.
265  *
266  * @global object
267  * @param int $id forum instance id
268  * @return bool success
269  */
270 function forum_delete_instance($id) {
271     global $DB;
273     if (!$forum = $DB->get_record('forum', array('id'=>$id))) {
274         return false;
275     }
276     if (!$cm = get_coursemodule_from_instance('forum', $forum->id)) {
277         return false;
278     }
279     if (!$course = $DB->get_record('course', array('id'=>$cm->course))) {
280         return false;
281     }
283     $context = context_module::instance($cm->id);
285     // now get rid of all files
286     $fs = get_file_storage();
287     $fs->delete_area_files($context->id);
289     $result = true;
291     \core_completion\api::update_completion_date_event($cm->id, 'forum', $forum->id, null);
293     // Delete digest and subscription preferences.
294     $DB->delete_records('forum_digests', array('forum' => $forum->id));
295     $DB->delete_records('forum_subscriptions', array('forum'=>$forum->id));
296     $DB->delete_records('forum_discussion_subs', array('forum' => $forum->id));
298     if ($discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id))) {
299         foreach ($discussions as $discussion) {
300             if (!forum_delete_discussion($discussion, true, $course, $cm, $forum)) {
301                 $result = false;
302             }
303         }
304     }
306     forum_tp_delete_read_records(-1, -1, -1, $forum->id);
308     if (!$DB->delete_records('forum', array('id'=>$forum->id))) {
309         $result = false;
310     }
312     forum_grade_item_delete($forum);
314     return $result;
318 /**
319  * Indicates API features that the forum supports.
320  *
321  * @uses FEATURE_GROUPS
322  * @uses FEATURE_GROUPINGS
323  * @uses FEATURE_MOD_INTRO
324  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
325  * @uses FEATURE_COMPLETION_HAS_RULES
326  * @uses FEATURE_GRADE_HAS_GRADE
327  * @uses FEATURE_GRADE_OUTCOMES
328  * @param string $feature
329  * @return mixed True if yes (some features may use other values)
330  */
331 function forum_supports($feature) {
332     switch($feature) {
333         case FEATURE_GROUPS:                  return true;
334         case FEATURE_GROUPINGS:               return true;
335         case FEATURE_MOD_INTRO:               return true;
336         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
337         case FEATURE_COMPLETION_HAS_RULES:    return true;
338         case FEATURE_GRADE_HAS_GRADE:         return true;
339         case FEATURE_GRADE_OUTCOMES:          return true;
340         case FEATURE_RATE:                    return true;
341         case FEATURE_BACKUP_MOODLE2:          return true;
342         case FEATURE_SHOW_DESCRIPTION:        return true;
343         case FEATURE_PLAGIARISM:              return true;
345         default: return null;
346     }
350 /**
351  * Obtains the automatic completion state for this forum based on any conditions
352  * in forum settings.
353  *
354  * @global object
355  * @global object
356  * @param object $course Course
357  * @param object $cm Course-module
358  * @param int $userid User ID
359  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
360  * @return bool True if completed, false if not. (If no conditions, then return
361  *   value depends on comparison type)
362  */
363 function forum_get_completion_state($course,$cm,$userid,$type) {
364     global $CFG,$DB;
366     // Get forum details
367     if (!($forum=$DB->get_record('forum',array('id'=>$cm->instance)))) {
368         throw new Exception("Can't find forum {$cm->instance}");
369     }
371     $result=$type; // Default return value
373     $postcountparams=array('userid'=>$userid,'forumid'=>$forum->id);
374     $postcountsql="
375 SELECT
376     COUNT(1)
377 FROM
378     {forum_posts} fp
379     INNER JOIN {forum_discussions} fd ON fp.discussion=fd.id
380 WHERE
381     fp.userid=:userid AND fd.forum=:forumid";
383     if ($forum->completiondiscussions) {
384         $value = $forum->completiondiscussions <=
385                  $DB->count_records('forum_discussions',array('forum'=>$forum->id,'userid'=>$userid));
386         if ($type == COMPLETION_AND) {
387             $result = $result && $value;
388         } else {
389             $result = $result || $value;
390         }
391     }
392     if ($forum->completionreplies) {
393         $value = $forum->completionreplies <=
394                  $DB->get_field_sql( $postcountsql.' AND fp.parent<>0',$postcountparams);
395         if ($type==COMPLETION_AND) {
396             $result = $result && $value;
397         } else {
398             $result = $result || $value;
399         }
400     }
401     if ($forum->completionposts) {
402         $value = $forum->completionposts <= $DB->get_field_sql($postcountsql,$postcountparams);
403         if ($type == COMPLETION_AND) {
404             $result = $result && $value;
405         } else {
406             $result = $result || $value;
407         }
408     }
410     return $result;
413 /**
414  * Create a message-id string to use in the custom headers of forum notification emails
415  *
416  * message-id is used by email clients to identify emails and to nest conversations
417  *
418  * @param int $postid The ID of the forum post we are notifying the user about
419  * @param int $usertoid The ID of the user being notified
420  * @return string A unique message-id
421  */
422 function forum_get_email_message_id($postid, $usertoid) {
423     return generate_email_messageid(hash('sha256', $postid . 'to' . $usertoid));
426 /**
427  * Removes properties from user record that are not necessary
428  * for sending post notifications.
429  * @param stdClass $user
430  * @return void, $user parameter is modified
431  */
432 function forum_cron_minimise_user_record(stdClass $user) {
434     // We store large amount of users in one huge array,
435     // make sure we do not store info there we do not actually need
436     // in mail generation code or messaging.
438     unset($user->institution);
439     unset($user->department);
440     unset($user->address);
441     unset($user->city);
442     unset($user->url);
443     unset($user->currentlogin);
444     unset($user->description);
445     unset($user->descriptionformat);
448 /**
449  * Function to be run periodically according to the scheduled task.
450  *
451  * Finds all posts that have yet to be mailed out, and mails them
452  * out to all subscribers as well as other maintance tasks.
453  *
454  * NOTE: Since 2.7.2 this function is run by scheduled task rather
455  * than standard cron.
456  *
457  * @todo MDL-44734 The function will be split up into seperate tasks.
458  */
459 function forum_cron() {
460     global $CFG, $USER, $DB, $PAGE;
462     $site = get_site();
464     // The main renderers.
465     $htmlout = $PAGE->get_renderer('mod_forum', 'email', 'htmlemail');
466     $textout = $PAGE->get_renderer('mod_forum', 'email', 'textemail');
467     $htmldigestfullout = $PAGE->get_renderer('mod_forum', 'emaildigestfull', 'htmlemail');
468     $textdigestfullout = $PAGE->get_renderer('mod_forum', 'emaildigestfull', 'textemail');
469     $htmldigestbasicout = $PAGE->get_renderer('mod_forum', 'emaildigestbasic', 'htmlemail');
470     $textdigestbasicout = $PAGE->get_renderer('mod_forum', 'emaildigestbasic', 'textemail');
472     // All users that are subscribed to any post that needs sending,
473     // please increase $CFG->extramemorylimit on large sites that
474     // send notifications to a large number of users.
475     $users = array();
476     $userscount = 0; // Cached user counter - count($users) in PHP is horribly slow!!!
478     // Status arrays.
479     $mailcount  = array();
480     $errorcount = array();
482     // caches
483     $discussions        = array();
484     $forums             = array();
485     $courses            = array();
486     $coursemodules      = array();
487     $subscribedusers    = array();
488     $messageinboundhandlers = array();
490     // Posts older than 2 days will not be mailed.  This is to avoid the problem where
491     // cron has not been running for a long time, and then suddenly people are flooded
492     // with mail from the past few weeks or months
493     $timenow   = time();
494     $endtime   = $timenow - $CFG->maxeditingtime;
495     $starttime = $endtime - 48 * 3600;   // Two days earlier
497     // Get the list of forum subscriptions for per-user per-forum maildigest settings.
498     $digestsset = $DB->get_recordset('forum_digests', null, '', 'id, userid, forum, maildigest');
499     $digests = array();
500     foreach ($digestsset as $thisrow) {
501         if (!isset($digests[$thisrow->forum])) {
502             $digests[$thisrow->forum] = array();
503         }
504         $digests[$thisrow->forum][$thisrow->userid] = $thisrow->maildigest;
505     }
506     $digestsset->close();
508     // Create the generic messageinboundgenerator.
509     $messageinboundgenerator = new \core\message\inbound\address_manager();
510     $messageinboundgenerator->set_handler('\mod_forum\message\inbound\reply_handler');
512     if ($posts = forum_get_unmailed_posts($starttime, $endtime, $timenow)) {
513         // Mark them all now as being mailed.  It's unlikely but possible there
514         // might be an error later so that a post is NOT actually mailed out,
515         // but since mail isn't crucial, we can accept this risk.  Doing it now
516         // prevents the risk of duplicated mails, which is a worse problem.
518         if (!forum_mark_old_posts_as_mailed($endtime)) {
519             mtrace('Errors occurred while trying to mark some posts as being mailed.');
520             return false;  // Don't continue trying to mail them, in case we are in a cron loop
521         }
523         // checking post validity, and adding users to loop through later
524         foreach ($posts as $pid => $post) {
526             $discussionid = $post->discussion;
527             if (!isset($discussions[$discussionid])) {
528                 if ($discussion = $DB->get_record('forum_discussions', array('id'=> $post->discussion))) {
529                     $discussions[$discussionid] = $discussion;
530                     \mod_forum\subscriptions::fill_subscription_cache($discussion->forum);
531                     \mod_forum\subscriptions::fill_discussion_subscription_cache($discussion->forum);
533                 } else {
534                     mtrace('Could not find discussion ' . $discussionid);
535                     unset($posts[$pid]);
536                     continue;
537                 }
538             }
539             $forumid = $discussions[$discussionid]->forum;
540             if (!isset($forums[$forumid])) {
541                 if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
542                     $forums[$forumid] = $forum;
543                 } else {
544                     mtrace('Could not find forum '.$forumid);
545                     unset($posts[$pid]);
546                     continue;
547                 }
548             }
549             $courseid = $forums[$forumid]->course;
550             if (!isset($courses[$courseid])) {
551                 if ($course = $DB->get_record('course', array('id' => $courseid))) {
552                     $courses[$courseid] = $course;
553                 } else {
554                     mtrace('Could not find course '.$courseid);
555                     unset($posts[$pid]);
556                     continue;
557                 }
558             }
559             if (!isset($coursemodules[$forumid])) {
560                 if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
561                     $coursemodules[$forumid] = $cm;
562                 } else {
563                     mtrace('Could not find course module for forum '.$forumid);
564                     unset($posts[$pid]);
565                     continue;
566                 }
567             }
569             $modcontext = context_module::instance($coursemodules[$forumid]->id);
571             // Save the Inbound Message datakey here to reduce DB queries later.
572             $messageinboundgenerator->set_data($pid);
573             $messageinboundhandlers[$pid] = $messageinboundgenerator->fetch_data_key();
575             // Caching subscribed users of each forum.
576             if (!isset($subscribedusers[$forumid])) {
577                 if ($subusers = \mod_forum\subscriptions::fetch_subscribed_users($forums[$forumid], 0, $modcontext, 'u.*', true)) {
579                     foreach ($subusers as $postuser) {
580                         // this user is subscribed to this forum
581                         $subscribedusers[$forumid][$postuser->id] = $postuser->id;
582                         $userscount++;
583                         if ($userscount > FORUM_CRON_USER_CACHE) {
584                             // Store minimal user info.
585                             $minuser = new stdClass();
586                             $minuser->id = $postuser->id;
587                             $users[$postuser->id] = $minuser;
588                         } else {
589                             // Cache full user record.
590                             forum_cron_minimise_user_record($postuser);
591                             $users[$postuser->id] = $postuser;
592                         }
593                     }
594                     // Release memory.
595                     unset($subusers);
596                     unset($postuser);
597                 }
598             }
599             $mailcount[$pid] = 0;
600             $errorcount[$pid] = 0;
601         }
602     }
604     if ($users && $posts) {
606         foreach ($users as $userto) {
607             // Terminate if processing of any account takes longer than 2 minutes.
608             core_php_time_limit::raise(120);
610             mtrace('Processing user ' . $userto->id);
612             // Init user caches - we keep the cache for one cycle only, otherwise it could consume too much memory.
613             if (isset($userto->username)) {
614                 $userto = clone($userto);
615             } else {
616                 $userto = $DB->get_record('user', array('id' => $userto->id));
617                 forum_cron_minimise_user_record($userto);
618             }
619             $userto->viewfullnames = array();
620             $userto->canpost       = array();
621             $userto->markposts     = array();
623             // Setup this user so that the capabilities are cached, and environment matches receiving user.
624             cron_setup_user($userto);
626             // Reset the caches.
627             foreach ($coursemodules as $forumid => $unused) {
628                 $coursemodules[$forumid]->cache       = new stdClass();
629                 $coursemodules[$forumid]->cache->caps = array();
630                 unset($coursemodules[$forumid]->uservisible);
631             }
633             foreach ($posts as $pid => $post) {
634                 $discussion = $discussions[$post->discussion];
635                 $forum      = $forums[$discussion->forum];
636                 $course     = $courses[$forum->course];
637                 $cm         =& $coursemodules[$forum->id];
639                 // Do some checks to see if we can bail out now.
641                 // Only active enrolled users are in the list of subscribers.
642                 // This does not necessarily mean that the user is subscribed to the forum or to the discussion though.
643                 if (!isset($subscribedusers[$forum->id][$userto->id])) {
644                     // The user does not subscribe to this forum.
645                     continue;
646                 }
648                 if (!\mod_forum\subscriptions::is_subscribed($userto->id, $forum, $post->discussion, $coursemodules[$forum->id])) {
649                     // The user does not subscribe to this forum, or to this specific discussion.
650                     continue;
651                 }
653                 if ($subscriptiontime = \mod_forum\subscriptions::fetch_discussion_subscription($forum->id, $userto->id)) {
654                     // Skip posts if the user subscribed to the discussion after it was created.
655                     if (isset($subscriptiontime[$post->discussion]) && ($subscriptiontime[$post->discussion] > $post->created)) {
656                         continue;
657                     }
658                 }
660                 // Don't send email if the forum is Q&A and the user has not posted.
661                 // Initial topics are still mailed.
662                 if ($forum->type == 'qanda' && !forum_get_user_posted_time($discussion->id, $userto->id) && $pid != $discussion->firstpost) {
663                     mtrace('Did not email ' . $userto->id.' because user has not posted in discussion');
664                     continue;
665                 }
667                 // Get info about the sending user.
668                 if (array_key_exists($post->userid, $users)) {
669                     // We might know the user already.
670                     $userfrom = $users[$post->userid];
671                     if (!isset($userfrom->idnumber)) {
672                         // Minimalised user info, fetch full record.
673                         $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
674                         forum_cron_minimise_user_record($userfrom);
675                     }
677                 } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
678                     forum_cron_minimise_user_record($userfrom);
679                     // Fetch only once if possible, we can add it to user list, it will be skipped anyway.
680                     if ($userscount <= FORUM_CRON_USER_CACHE) {
681                         $userscount++;
682                         $users[$userfrom->id] = $userfrom;
683                     }
684                 } else {
685                     mtrace('Could not find user ' . $post->userid . ', author of post ' . $post->id . '. Unable to send message.');
686                     continue;
687                 }
689                 // Note: If we want to check that userto and userfrom are not the same person this is probably the spot to do it.
691                 // Setup global $COURSE properly - needed for roles and languages.
692                 cron_setup_user($userto, $course);
694                 // Fill caches.
695                 if (!isset($userto->viewfullnames[$forum->id])) {
696                     $modcontext = context_module::instance($cm->id);
697                     $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
698                 }
699                 if (!isset($userto->canpost[$discussion->id])) {
700                     $modcontext = context_module::instance($cm->id);
701                     $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
702                 }
703                 if (!isset($userfrom->groups[$forum->id])) {
704                     if (!isset($userfrom->groups)) {
705                         $userfrom->groups = array();
706                         if (isset($users[$userfrom->id])) {
707                             $users[$userfrom->id]->groups = array();
708                         }
709                     }
710                     $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
711                     if (isset($users[$userfrom->id])) {
712                         $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
713                     }
714                 }
716                 // Make sure groups allow this user to see this email.
717                 if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {
718                     // Groups are being used.
719                     if (!groups_group_exists($discussion->groupid)) {
720                         // Can't find group - be safe and don't this message.
721                         continue;
722                     }
724                     if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $modcontext)) {
725                         // Do not send posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS.
726                         continue;
727                     }
728                 }
730                 // Make sure we're allowed to see the post.
731                 if (!forum_user_can_see_post($forum, $discussion, $post, null, $cm)) {
732                     mtrace('User ' . $userto->id .' can not see ' . $post->id . '. Not sending message.');
733                     continue;
734                 }
736                 // OK so we need to send the email.
738                 // Does the user want this post in a digest?  If so postpone it for now.
739                 $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
741                 if ($maildigest > 0) {
742                     // This user wants the mails to be in digest form.
743                     $queue = new stdClass();
744                     $queue->userid       = $userto->id;
745                     $queue->discussionid = $discussion->id;
746                     $queue->postid       = $post->id;
747                     $queue->timemodified = $post->created;
748                     $DB->insert_record('forum_queue', $queue);
749                     continue;
750                 }
752                 // Prepare to actually send the post now, and build up the content.
754                 $cleanforumname = str_replace('"', "'", strip_tags(format_string($forum->name)));
756                 $userfrom->customheaders = array (
757                     // Headers to make emails easier to track.
758                     'List-Id: "'        . $cleanforumname . '" ' . generate_email_messageid('moodleforum' . $forum->id),
759                     'List-Help: '       . $CFG->wwwroot . '/mod/forum/view.php?f=' . $forum->id,
760                     'Message-ID: '      . forum_get_email_message_id($post->id, $userto->id),
761                     'X-Course-Id: '     . $course->id,
762                     'X-Course-Name: '   . format_string($course->fullname, true),
764                     // Headers to help prevent auto-responders.
765                     'Precedence: Bulk',
766                     'X-Auto-Response-Suppress: All',
767                     'Auto-Submitted: auto-generated',
768                 );
770                 $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
772                 // Generate a reply-to address from using the Inbound Message handler.
773                 $replyaddress = null;
774                 if ($userto->canpost[$discussion->id] && array_key_exists($post->id, $messageinboundhandlers)) {
775                     $messageinboundgenerator->set_data($post->id, $messageinboundhandlers[$post->id]);
776                     $replyaddress = $messageinboundgenerator->generate($userto->id);
777                 }
779                 if (!isset($userto->canpost[$discussion->id])) {
780                     $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
781                 } else {
782                     $canreply = $userto->canpost[$discussion->id];
783                 }
785                 $data = new \mod_forum\output\forum_post_email(
786                         $course,
787                         $cm,
788                         $forum,
789                         $discussion,
790                         $post,
791                         $userfrom,
792                         $userto,
793                         $canreply
794                     );
796                 $userfrom->customheaders[] = sprintf('List-Unsubscribe: <%s>',
797                     $data->get_unsubscribediscussionlink());
799                 if (!isset($userto->viewfullnames[$forum->id])) {
800                     $data->viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
801                 } else {
802                     $data->viewfullnames = $userto->viewfullnames[$forum->id];
803                 }
805                 // Not all of these variables are used in the default language
806                 // string but are made available to support custom subjects.
807                 $a = new stdClass();
808                 $a->subject = $data->get_subject();
809                 $a->forumname = $cleanforumname;
810                 $a->sitefullname = format_string($site->fullname);
811                 $a->siteshortname = format_string($site->shortname);
812                 $a->courseidnumber = $data->get_courseidnumber();
813                 $a->coursefullname = $data->get_coursefullname();
814                 $a->courseshortname = $data->get_coursename();
815                 $postsubject = html_to_text(get_string('postmailsubject', 'forum', $a), 0);
817                 $rootid = forum_get_email_message_id($discussion->firstpost, $userto->id);
819                 if ($post->parent) {
820                     // This post is a reply, so add reply header (RFC 2822).
821                     $parentid = forum_get_email_message_id($post->parent, $userto->id);
822                     $userfrom->customheaders[] = "In-Reply-To: $parentid";
824                     // If the post is deeply nested we also reference the parent message id and
825                     // the root message id (if different) to aid threading when parts of the email
826                     // conversation have been deleted (RFC1036).
827                     if ($post->parent != $discussion->firstpost) {
828                         $userfrom->customheaders[] = "References: $rootid $parentid";
829                     } else {
830                         $userfrom->customheaders[] = "References: $parentid";
831                     }
832                 }
834                 // MS Outlook / Office uses poorly documented and non standard headers, including
835                 // Thread-Topic which overrides the Subject and shouldn't contain Re: or Fwd: etc.
836                 $a->subject = $discussion->name;
837                 $threadtopic = html_to_text(get_string('postmailsubject', 'forum', $a), 0);
838                 $userfrom->customheaders[] = "Thread-Topic: $threadtopic";
839                 $userfrom->customheaders[] = "Thread-Index: " . substr($rootid, 1, 28);
841                 // Send the post now!
842                 mtrace('Sending ', '');
844                 $eventdata = new \core\message\message();
845                 $eventdata->courseid            = $course->id;
846                 $eventdata->component           = 'mod_forum';
847                 $eventdata->name                = 'posts';
848                 $eventdata->userfrom            = $userfrom;
849                 $eventdata->userto              = $userto;
850                 $eventdata->subject             = $postsubject;
851                 $eventdata->fullmessage         = $textout->render($data);
852                 $eventdata->fullmessageformat   = FORMAT_PLAIN;
853                 $eventdata->fullmessagehtml     = $htmlout->render($data);
854                 $eventdata->notification        = 1;
855                 $eventdata->replyto             = $replyaddress;
856                 if (!empty($replyaddress)) {
857                     // Add extra text to email messages if they can reply back.
858                     $textfooter = "\n\n" . get_string('replytopostbyemail', 'mod_forum');
859                     $htmlfooter = html_writer::tag('p', get_string('replytopostbyemail', 'mod_forum'));
860                     $additionalcontent = array('fullmessage' => array('footer' => $textfooter),
861                                      'fullmessagehtml' => array('footer' => $htmlfooter));
862                     $eventdata->set_additional_content('email', $additionalcontent);
863                 }
865                 $smallmessagestrings = new stdClass();
866                 $smallmessagestrings->user          = fullname($userfrom);
867                 $smallmessagestrings->forumname     = "$shortname: " . format_string($forum->name, true) . ": " . $discussion->name;
868                 $smallmessagestrings->message       = $post->message;
870                 // Make sure strings are in message recipients language.
871                 $eventdata->smallmessage = get_string_manager()->get_string('smallmessage', 'forum', $smallmessagestrings, $userto->lang);
873                 $contexturl = new moodle_url('/mod/forum/discuss.php', array('d' => $discussion->id), 'p' . $post->id);
874                 $eventdata->contexturl = $contexturl->out();
875                 $eventdata->contexturlname = $discussion->name;
877                 $mailresult = message_send($eventdata);
878                 if (!$mailresult) {
879                     mtrace("Error: mod/forum/lib.php forum_cron(): Could not send out mail for id $post->id to user $userto->id".
880                             " ($userto->email) .. not trying again.");
881                     $errorcount[$post->id]++;
882                 } else {
883                     $mailcount[$post->id]++;
885                     // Mark post as read if forum_usermarksread is set off.
886                     if (!$CFG->forum_usermarksread) {
887                         $userto->markposts[$post->id] = $post->id;
888                     }
889                 }
891                 mtrace('post ' . $post->id . ': ' . $post->subject);
892             }
894             // Mark processed posts as read.
895             if (get_user_preferences('forum_markasreadonnotification', 1, $userto->id) == 1) {
896                 forum_tp_mark_posts_read($userto, $userto->markposts);
897             }
899             unset($userto);
900         }
901     }
903     if ($posts) {
904         foreach ($posts as $post) {
905             mtrace($mailcount[$post->id]." users were sent post $post->id, '$post->subject'");
906             if ($errorcount[$post->id]) {
907                 $DB->set_field('forum_posts', 'mailed', FORUM_MAILED_ERROR, array('id' => $post->id));
908             }
909         }
910     }
912     // release some memory
913     unset($subscribedusers);
914     unset($mailcount);
915     unset($errorcount);
917     cron_setup_user();
919     $sitetimezone = core_date::get_server_timezone();
921     // Now see if there are any digest mails waiting to be sent, and if we should send them
923     mtrace('Starting digest processing...');
925     core_php_time_limit::raise(300); // terminate if not able to fetch all digests in 5 minutes
927     if (!isset($CFG->digestmailtimelast)) {    // To catch the first time
928         set_config('digestmailtimelast', 0);
929     }
931     $timenow = time();
932     $digesttime = usergetmidnight($timenow, $sitetimezone) + ($CFG->digestmailtime * 3600);
934     // Delete any really old ones (normally there shouldn't be any)
935     $weekago = $timenow - (7 * 24 * 3600);
936     $DB->delete_records_select('forum_queue', "timemodified < ?", array($weekago));
937     mtrace ('Cleaned old digest records');
939     if ($CFG->digestmailtimelast < $digesttime and $timenow > $digesttime) {
941         mtrace('Sending forum digests: '.userdate($timenow, '', $sitetimezone));
943         $digestposts_rs = $DB->get_recordset_select('forum_queue', "timemodified < ?", array($digesttime));
945         if ($digestposts_rs->valid()) {
947             // We have work to do
948             $usermailcount = 0;
950             //caches - reuse the those filled before too
951             $discussionposts = array();
952             $userdiscussions = array();
954             foreach ($digestposts_rs as $digestpost) {
955                 if (!isset($posts[$digestpost->postid])) {
956                     if ($post = $DB->get_record('forum_posts', array('id' => $digestpost->postid))) {
957                         $posts[$digestpost->postid] = $post;
958                     } else {
959                         continue;
960                     }
961                 }
962                 $discussionid = $digestpost->discussionid;
963                 if (!isset($discussions[$discussionid])) {
964                     if ($discussion = $DB->get_record('forum_discussions', array('id' => $discussionid))) {
965                         $discussions[$discussionid] = $discussion;
966                     } else {
967                         continue;
968                     }
969                 }
970                 $forumid = $discussions[$discussionid]->forum;
971                 if (!isset($forums[$forumid])) {
972                     if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
973                         $forums[$forumid] = $forum;
974                     } else {
975                         continue;
976                     }
977                 }
979                 $courseid = $forums[$forumid]->course;
980                 if (!isset($courses[$courseid])) {
981                     if ($course = $DB->get_record('course', array('id' => $courseid))) {
982                         $courses[$courseid] = $course;
983                     } else {
984                         continue;
985                     }
986                 }
988                 if (!isset($coursemodules[$forumid])) {
989                     if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
990                         $coursemodules[$forumid] = $cm;
991                     } else {
992                         continue;
993                     }
994                 }
995                 $userdiscussions[$digestpost->userid][$digestpost->discussionid] = $digestpost->discussionid;
996                 $discussionposts[$digestpost->discussionid][$digestpost->postid] = $digestpost->postid;
997             }
998             $digestposts_rs->close(); /// Finished iteration, let's close the resultset
1000             // Data collected, start sending out emails to each user
1001             foreach ($userdiscussions as $userid => $thesediscussions) {
1003                 core_php_time_limit::raise(120); // terminate if processing of any account takes longer than 2 minutes
1005                 cron_setup_user();
1007                 mtrace(get_string('processingdigest', 'forum', $userid), '... ');
1009                 // First of all delete all the queue entries for this user
1010                 $DB->delete_records_select('forum_queue', "userid = ? AND timemodified < ?", array($userid, $digesttime));
1012                 // Init user caches - we keep the cache for one cycle only,
1013                 // otherwise it would unnecessarily consume memory.
1014                 if (array_key_exists($userid, $users) and isset($users[$userid]->username)) {
1015                     $userto = clone($users[$userid]);
1016                 } else {
1017                     $userto = $DB->get_record('user', array('id' => $userid));
1018                     forum_cron_minimise_user_record($userto);
1019                 }
1020                 $userto->viewfullnames = array();
1021                 $userto->canpost       = array();
1022                 $userto->markposts     = array();
1024                 // Override the language and timezone of the "current" user, so that
1025                 // mail is customised for the receiver.
1026                 cron_setup_user($userto);
1028                 $postsubject = get_string('digestmailsubject', 'forum', format_string($site->shortname, true));
1030                 $headerdata = new stdClass();
1031                 $headerdata->sitename = format_string($site->fullname, true);
1032                 $headerdata->userprefs = $CFG->wwwroot.'/user/forum.php?id='.$userid.'&amp;course='.$site->id;
1034                 $posttext = get_string('digestmailheader', 'forum', $headerdata)."\n\n";
1035                 $headerdata->userprefs = '<a target="_blank" href="'.$headerdata->userprefs.'">'.get_string('digestmailprefs', 'forum').'</a>';
1037                 $posthtml = '<p>'.get_string('digestmailheader', 'forum', $headerdata).'</p>'
1038                     . '<br /><hr size="1" noshade="noshade" />';
1040                 foreach ($thesediscussions as $discussionid) {
1042                     core_php_time_limit::raise(120);   // to be reset for each post
1044                     $discussion = $discussions[$discussionid];
1045                     $forum      = $forums[$discussion->forum];
1046                     $course     = $courses[$forum->course];
1047                     $cm         = $coursemodules[$forum->id];
1049                     //override language
1050                     cron_setup_user($userto, $course);
1052                     // Fill caches
1053                     if (!isset($userto->viewfullnames[$forum->id])) {
1054                         $modcontext = context_module::instance($cm->id);
1055                         $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
1056                     }
1057                     if (!isset($userto->canpost[$discussion->id])) {
1058                         $modcontext = context_module::instance($cm->id);
1059                         $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1060                     }
1062                     $strforums      = get_string('forums', 'forum');
1063                     $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
1064                     $canreply       = $userto->canpost[$discussion->id];
1065                     $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1067                     $posttext .= "\n \n";
1068                     $posttext .= '=====================================================================';
1069                     $posttext .= "\n \n";
1070                     $posttext .= "$shortname -> $strforums -> ".format_string($forum->name,true);
1071                     if ($discussion->name != $forum->name) {
1072                         $posttext  .= " -> ".format_string($discussion->name,true);
1073                     }
1074                     $posttext .= "\n";
1075                     $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1076                     $posttext .= "\n";
1078                     $posthtml .= "<p><font face=\"sans-serif\">".
1079                     "<a target=\"_blank\" href=\"$CFG->wwwroot/course/view.php?id=$course->id\">$shortname</a> -> ".
1080                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/index.php?id=$course->id\">$strforums</a> -> ".
1081                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/view.php?f=$forum->id\">".format_string($forum->name,true)."</a>";
1082                     if ($discussion->name == $forum->name) {
1083                         $posthtml .= "</font></p>";
1084                     } else {
1085                         $posthtml .= " -> <a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id\">".format_string($discussion->name,true)."</a></font></p>";
1086                     }
1087                     $posthtml .= '<p>';
1089                     $postsarray = $discussionposts[$discussionid];
1090                     sort($postsarray);
1091                     $sentcount = 0;
1093                     foreach ($postsarray as $postid) {
1094                         $post = $posts[$postid];
1096                         if (array_key_exists($post->userid, $users)) { // we might know him/her already
1097                             $userfrom = $users[$post->userid];
1098                             if (!isset($userfrom->idnumber)) {
1099                                 $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
1100                                 forum_cron_minimise_user_record($userfrom);
1101                             }
1103                         } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
1104                             forum_cron_minimise_user_record($userfrom);
1105                             if ($userscount <= FORUM_CRON_USER_CACHE) {
1106                                 $userscount++;
1107                                 $users[$userfrom->id] = $userfrom;
1108                             }
1110                         } else {
1111                             mtrace('Could not find user '.$post->userid);
1112                             continue;
1113                         }
1115                         if (!isset($userfrom->groups[$forum->id])) {
1116                             if (!isset($userfrom->groups)) {
1117                                 $userfrom->groups = array();
1118                                 if (isset($users[$userfrom->id])) {
1119                                     $users[$userfrom->id]->groups = array();
1120                                 }
1121                             }
1122                             $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
1123                             if (isset($users[$userfrom->id])) {
1124                                 $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
1125                             }
1126                         }
1128                         // Headers to help prevent auto-responders.
1129                         $userfrom->customheaders = array(
1130                                 "Precedence: Bulk",
1131                                 'X-Auto-Response-Suppress: All',
1132                                 'Auto-Submitted: auto-generated',
1133                             );
1135                         $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
1136                         if (!isset($userto->canpost[$discussion->id])) {
1137                             $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1138                         } else {
1139                             $canreply = $userto->canpost[$discussion->id];
1140                         }
1142                         $data = new \mod_forum\output\forum_post_email(
1143                                 $course,
1144                                 $cm,
1145                                 $forum,
1146                                 $discussion,
1147                                 $post,
1148                                 $userfrom,
1149                                 $userto,
1150                                 $canreply
1151                             );
1153                         if (!isset($userto->viewfullnames[$forum->id])) {
1154                             $data->viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
1155                         } else {
1156                             $data->viewfullnames = $userto->viewfullnames[$forum->id];
1157                         }
1159                         if ($maildigest == 2) {
1160                             // Subjects and link only.
1161                             $posttext .= $textdigestbasicout->render($data);
1162                             $posthtml .= $htmldigestbasicout->render($data);
1163                         } else {
1164                             // The full treatment.
1165                             $posttext .= $textdigestfullout->render($data);
1166                             $posthtml .= $htmldigestfullout->render($data);
1168                             // Create an array of postid's for this user to mark as read.
1169                             if (!$CFG->forum_usermarksread) {
1170                                 $userto->markposts[$post->id] = $post->id;
1171                             }
1172                         }
1173                         $sentcount++;
1174                     }
1175                     $footerlinks = array();
1176                     if ($canunsubscribe) {
1177                         $footerlinks[] = "<a href=\"$CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id\">" . get_string("unsubscribe", "forum") . "</a>";
1178                     } else {
1179                         $footerlinks[] = get_string("everyoneissubscribed", "forum");
1180                     }
1181                     $footerlinks[] = "<a href='{$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}'>" . get_string("digestmailpost", "forum") . '</a>';
1182                     $posthtml .= "\n<div class='mdl-right'><font size=\"1\">" . implode('&nbsp;', $footerlinks) . '</font></div>';
1183                     $posthtml .= '<hr size="1" noshade="noshade" /></p>';
1184                 }
1186                 if (empty($userto->mailformat) || $userto->mailformat != 1) {
1187                     // This user DOESN'T want to receive HTML
1188                     $posthtml = '';
1189                 }
1191                 $eventdata = new \core\message\message();
1192                 $eventdata->courseid            = SITEID;
1193                 $eventdata->component           = 'mod_forum';
1194                 $eventdata->name                = 'digests';
1195                 $eventdata->userfrom            = core_user::get_noreply_user();
1196                 $eventdata->userto              = $userto;
1197                 $eventdata->subject             = $postsubject;
1198                 $eventdata->fullmessage         = $posttext;
1199                 $eventdata->fullmessageformat   = FORMAT_PLAIN;
1200                 $eventdata->fullmessagehtml     = $posthtml;
1201                 $eventdata->notification        = 1;
1202                 $eventdata->smallmessage        = get_string('smallmessagedigest', 'forum', $sentcount);
1203                 $mailresult = message_send($eventdata);
1205                 if (!$mailresult) {
1206                     mtrace("ERROR: mod/forum/cron.php: Could not send out digest mail to user $userto->id ".
1207                         "($userto->email)... not trying again.");
1208                 } else {
1209                     mtrace("success.");
1210                     $usermailcount++;
1212                     // Mark post as read if forum_usermarksread is set off
1213                     if (get_user_preferences('forum_markasreadonnotification', 1, $userto->id) == 1) {
1214                         forum_tp_mark_posts_read($userto, $userto->markposts);
1215                     }
1216                 }
1217             }
1218         }
1219     /// We have finishied all digest emails, update $CFG->digestmailtimelast
1220         set_config('digestmailtimelast', $timenow);
1221     }
1223     cron_setup_user();
1225     if (!empty($usermailcount)) {
1226         mtrace(get_string('digestsentusers', 'forum', $usermailcount));
1227     }
1229     if (!empty($CFG->forum_lastreadclean)) {
1230         $timenow = time();
1231         if ($CFG->forum_lastreadclean + (24*3600) < $timenow) {
1232             set_config('forum_lastreadclean', $timenow);
1233             mtrace('Removing old forum read tracking info...');
1234             forum_tp_clean_read_records();
1235         }
1236     } else {
1237         set_config('forum_lastreadclean', time());
1238     }
1240     return true;
1243 /**
1244  *
1245  * @param object $course
1246  * @param object $user
1247  * @param object $mod TODO this is not used in this function, refactor
1248  * @param object $forum
1249  * @return object A standard object with 2 variables: info (number of posts for this user) and time (last modified)
1250  */
1251 function forum_user_outline($course, $user, $mod, $forum) {
1252     global $CFG;
1253     require_once("$CFG->libdir/gradelib.php");
1254     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1255     if (empty($grades->items[0]->grades)) {
1256         $grade = false;
1257     } else {
1258         $grade = reset($grades->items[0]->grades);
1259     }
1261     $count = forum_count_user_posts($forum->id, $user->id);
1263     if ($count && $count->postcount > 0) {
1264         $result = new stdClass();
1265         $result->info = get_string("numposts", "forum", $count->postcount);
1266         $result->time = $count->lastpost;
1267         if ($grade) {
1268             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1269         }
1270         return $result;
1271     } else if ($grade) {
1272         $result = new stdClass();
1273         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1275         //datesubmitted == time created. dategraded == time modified or time overridden
1276         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1277         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1278         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1279             $result->time = $grade->dategraded;
1280         } else {
1281             $result->time = $grade->datesubmitted;
1282         }
1284         return $result;
1285     }
1286     return NULL;
1290 /**
1291  * @global object
1292  * @global object
1293  * @param object $coure
1294  * @param object $user
1295  * @param object $mod
1296  * @param object $forum
1297  */
1298 function forum_user_complete($course, $user, $mod, $forum) {
1299     global $CFG,$USER, $OUTPUT;
1300     require_once("$CFG->libdir/gradelib.php");
1302     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1303     if (!empty($grades->items[0]->grades)) {
1304         $grade = reset($grades->items[0]->grades);
1305         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1306         if ($grade->str_feedback) {
1307             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1308         }
1309     }
1311     if ($posts = forum_get_user_posts($forum->id, $user->id)) {
1313         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $course->id)) {
1314             print_error('invalidcoursemodule');
1315         }
1316         $discussions = forum_get_user_involved_discussions($forum->id, $user->id);
1318         foreach ($posts as $post) {
1319             if (!isset($discussions[$post->discussion])) {
1320                 continue;
1321             }
1322             $discussion = $discussions[$post->discussion];
1324             forum_print_post_start($post);
1325             forum_print_post($post, $discussion, $forum, $cm, $course, false, false, false);
1326             forum_print_post_end($post);
1327         }
1328     } else {
1329         echo "<p>".get_string("noposts", "forum")."</p>";
1330     }
1333 /**
1334  * Filters the forum discussions according to groups membership and config.
1335  *
1336  * @deprecated since 3.3
1337  * @todo The final deprecation of this function will take place in Moodle 3.7 - see MDL-57487.
1338  * @since  Moodle 2.8, 2.7.1, 2.6.4
1339  * @param  array $discussions Discussions with new posts array
1340  * @return array Forums with the number of new posts
1341  */
1342 function forum_filter_user_groups_discussions($discussions) {
1344     debugging('The function forum_filter_user_groups_discussions() is now deprecated.', DEBUG_DEVELOPER);
1346     // Group the remaining discussions posts by their forumid.
1347     $filteredforums = array();
1349     // Discard not visible groups.
1350     foreach ($discussions as $discussion) {
1352         // Course data is already cached.
1353         $instances = get_fast_modinfo($discussion->course)->get_instances();
1354         $forum = $instances['forum'][$discussion->forum];
1356         // Continue if the user should not see this discussion.
1357         if (!forum_is_user_group_discussion($forum, $discussion->groupid)) {
1358             continue;
1359         }
1361         // Grouping results by forum.
1362         if (empty($filteredforums[$forum->instance])) {
1363             $filteredforums[$forum->instance] = new stdClass();
1364             $filteredforums[$forum->instance]->id = $forum->id;
1365             $filteredforums[$forum->instance]->count = 0;
1366         }
1367         $filteredforums[$forum->instance]->count += $discussion->count;
1369     }
1371     return $filteredforums;
1374 /**
1375  * Returns whether the discussion group is visible by the current user or not.
1376  *
1377  * @since Moodle 2.8, 2.7.1, 2.6.4
1378  * @param cm_info $cm The discussion course module
1379  * @param int $discussiongroupid The discussion groupid
1380  * @return bool
1381  */
1382 function forum_is_user_group_discussion(cm_info $cm, $discussiongroupid) {
1384     if ($discussiongroupid == -1 || $cm->effectivegroupmode != SEPARATEGROUPS) {
1385         return true;
1386     }
1388     if (isguestuser()) {
1389         return false;
1390     }
1392     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id)) ||
1393             in_array($discussiongroupid, $cm->get_modinfo()->get_groups($cm->groupingid))) {
1394         return true;
1395     }
1397     return false;
1400 /**
1401  * @deprecated since 3.3
1402  * @todo The final deprecation of this function will take place in Moodle 3.7 - see MDL-57487.
1403  * @global object
1404  * @global object
1405  * @global object
1406  * @param array $courses
1407  * @param array $htmlarray
1408  */
1409 function forum_print_overview($courses,&$htmlarray) {
1410     global $USER, $CFG, $DB, $SESSION;
1412     debugging('The function forum_print_overview() is now deprecated.', DEBUG_DEVELOPER);
1414     if (empty($courses) || !is_array($courses) || count($courses) == 0) {
1415         return array();
1416     }
1418     if (!$forums = get_all_instances_in_courses('forum',$courses)) {
1419         return;
1420     }
1422     // Courses to search for new posts
1423     $coursessqls = array();
1424     $params = array();
1425     foreach ($courses as $course) {
1427         // If the user has never entered into the course all posts are pending
1428         if ($course->lastaccess == 0) {
1429             $coursessqls[] = '(d.course = ?)';
1430             $params[] = $course->id;
1432         // Only posts created after the course last access
1433         } else {
1434             $coursessqls[] = '(d.course = ? AND p.created > ?)';
1435             $params[] = $course->id;
1436             $params[] = $course->lastaccess;
1437         }
1438     }
1439     $params[] = $USER->id;
1440     $coursessql = implode(' OR ', $coursessqls);
1442     $sql = "SELECT d.id, d.forum, d.course, d.groupid, COUNT(*) as count "
1443                 .'FROM {forum_discussions} d '
1444                 .'JOIN {forum_posts} p ON p.discussion = d.id '
1445                 ."WHERE ($coursessql) "
1446                 .'AND p.deleted <> 1 '
1447                 .'AND p.userid != ? '
1448                 .'AND (d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?)) '
1449                 .'GROUP BY d.id, d.forum, d.course, d.groupid '
1450                 .'ORDER BY d.course, d.forum';
1451     $params[] = time();
1452     $params[] = time();
1454     // Avoid warnings.
1455     if (!$discussions = $DB->get_records_sql($sql, $params)) {
1456         $discussions = array();
1457     }
1459     $forumsnewposts = forum_filter_user_groups_discussions($discussions);
1461     // also get all forum tracking stuff ONCE.
1462     $trackingforums = array();
1463     foreach ($forums as $forum) {
1464         if (forum_tp_can_track_forums($forum)) {
1465             $trackingforums[$forum->id] = $forum;
1466         }
1467     }
1469     if (count($trackingforums) > 0) {
1470         $cutoffdate = isset($CFG->forum_oldpostdays) ? (time() - ($CFG->forum_oldpostdays*24*60*60)) : 0;
1471         $sql = 'SELECT d.forum,d.course,COUNT(p.id) AS count '.
1472             ' FROM {forum_posts} p '.
1473             ' JOIN {forum_discussions} d ON p.discussion = d.id '.
1474             ' LEFT JOIN {forum_read} r ON r.postid = p.id AND r.userid = ? WHERE p.deleted <> 1 AND (';
1475         $params = array($USER->id);
1477         foreach ($trackingforums as $track) {
1478             $sql .= '(d.forum = ? AND (d.groupid = -1 OR d.groupid = 0 OR d.groupid = ?)) OR ';
1479             $params[] = $track->id;
1480             if (isset($SESSION->currentgroup[$track->course])) {
1481                 $groupid =  $SESSION->currentgroup[$track->course];
1482             } else {
1483                 // get first groupid
1484                 $groupids = groups_get_all_groups($track->course, $USER->id);
1485                 if ($groupids) {
1486                     reset($groupids);
1487                     $groupid = key($groupids);
1488                     $SESSION->currentgroup[$track->course] = $groupid;
1489                 } else {
1490                     $groupid = 0;
1491                 }
1492                 unset($groupids);
1493             }
1494             $params[] = $groupid;
1495         }
1496         $sql = substr($sql,0,-3); // take off the last OR
1497         $sql .= ') AND p.modified >= ? AND r.id is NULL ';
1498         $sql .= 'AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)) ';
1499         $sql .= 'GROUP BY d.forum,d.course';
1500         $params[] = $cutoffdate;
1501         $params[] = time();
1502         $params[] = time();
1504         if (!$unread = $DB->get_records_sql($sql, $params)) {
1505             $unread = array();
1506         }
1507     } else {
1508         $unread = array();
1509     }
1511     if (empty($unread) and empty($forumsnewposts)) {
1512         return;
1513     }
1515     $strforum = get_string('modulename','forum');
1517     foreach ($forums as $forum) {
1518         $str = '';
1519         $count = 0;
1520         $thisunread = 0;
1521         $showunread = false;
1522         // either we have something from logs, or trackposts, or nothing.
1523         if (array_key_exists($forum->id, $forumsnewposts) && !empty($forumsnewposts[$forum->id])) {
1524             $count = $forumsnewposts[$forum->id]->count;
1525         }
1526         if (array_key_exists($forum->id,$unread)) {
1527             $thisunread = $unread[$forum->id]->count;
1528             $showunread = true;
1529         }
1530         if ($count > 0 || $thisunread > 0) {
1531             $str .= '<div class="overview forum"><div class="name">'.$strforum.': <a title="'.$strforum.'" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.
1532                 $forum->name.'</a></div>';
1533             $str .= '<div class="info"><span class="postsincelogin">';
1534             $str .= get_string('overviewnumpostssince', 'forum', $count)."</span>";
1535             if (!empty($showunread)) {
1536                 $str .= '<div class="unreadposts">'.get_string('overviewnumunread', 'forum', $thisunread).'</div>';
1537             }
1538             $str .= '</div></div>';
1539         }
1540         if (!empty($str)) {
1541             if (!array_key_exists($forum->course,$htmlarray)) {
1542                 $htmlarray[$forum->course] = array();
1543             }
1544             if (!array_key_exists('forum',$htmlarray[$forum->course])) {
1545                 $htmlarray[$forum->course]['forum'] = ''; // initialize, avoid warnings
1546             }
1547             $htmlarray[$forum->course]['forum'] .= $str;
1548         }
1549     }
1552 /**
1553  * Given a course and a date, prints a summary of all the new
1554  * messages posted in the course since that date
1555  *
1556  * @global object
1557  * @global object
1558  * @global object
1559  * @uses CONTEXT_MODULE
1560  * @uses VISIBLEGROUPS
1561  * @param object $course
1562  * @param bool $viewfullnames capability
1563  * @param int $timestart
1564  * @return bool success
1565  */
1566 function forum_print_recent_activity($course, $viewfullnames, $timestart) {
1567     global $CFG, $USER, $DB, $OUTPUT;
1569     // do not use log table if possible, it may be huge and is expensive to join with other tables
1571     $allnamefields = user_picture::fields('u', null, 'duserid');
1572     if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
1573                                               d.timestart, d.timeend, $allnamefields
1574                                          FROM {forum_posts} p
1575                                               JOIN {forum_discussions} d ON d.id = p.discussion
1576                                               JOIN {forum} f             ON f.id = d.forum
1577                                               JOIN {user} u              ON u.id = p.userid
1578                                         WHERE p.created > ? AND f.course = ? AND p.deleted <> 1
1579                                      ORDER BY p.id ASC", array($timestart, $course->id))) { // order by initial posting date
1580          return false;
1581     }
1583     $modinfo = get_fast_modinfo($course);
1585     $groupmodes = array();
1586     $cms    = array();
1588     $strftimerecent = get_string('strftimerecent');
1590     $printposts = array();
1591     foreach ($posts as $post) {
1592         if (!isset($modinfo->instances['forum'][$post->forum])) {
1593             // not visible
1594             continue;
1595         }
1596         $cm = $modinfo->instances['forum'][$post->forum];
1597         if (!$cm->uservisible) {
1598             continue;
1599         }
1600         $context = context_module::instance($cm->id);
1602         if (!has_capability('mod/forum:viewdiscussion', $context)) {
1603             continue;
1604         }
1606         if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
1607           and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
1608             if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1609                 continue;
1610             }
1611         }
1613         // Check that the user can see the discussion.
1614         if (forum_is_user_group_discussion($cm, $post->groupid)) {
1615             $printposts[] = $post;
1616         }
1618     }
1619     unset($posts);
1621     if (!$printposts) {
1622         return false;
1623     }
1625     echo $OUTPUT->heading(get_string('newforumposts', 'forum').':', 3);
1626     $list = html_writer::start_tag('ul', ['class' => 'unlist']);
1628     foreach ($printposts as $post) {
1629         $subjectclass = empty($post->parent) ? ' bold' : '';
1630         $authorhidden = forum_is_author_hidden($post, (object) ['type' => $post->forumtype]);
1632         $list .= html_writer::start_tag('li');
1633         $list .= html_writer::start_div('head');
1634         $list .= html_writer::div(userdate_htmltime($post->modified, $strftimerecent), 'date');
1635         if (!$authorhidden) {
1636             $list .= html_writer::div(fullname($post, $viewfullnames), 'name');
1637         }
1638         $list .= html_writer::end_div(); // Head.
1640         $list .= html_writer::start_div('info' . $subjectclass);
1641         $discussionurl = new moodle_url('/mod/forum/discuss.php', ['d' => $post->discussion]);
1642         if (!empty($post->parent)) {
1643             $discussionurl->param('parent', $post->parent);
1644             $discussionurl->set_anchor('p'. $post->id);
1645         }
1646         $post->subject = break_up_long_words(format_string($post->subject, true));
1647         $list .= html_writer::link($discussionurl, $post->subject, ['rel' => 'bookmark']);
1648         $list .= html_writer::end_div(); // Info.
1649         $list .= html_writer::end_tag('li');
1650     }
1652     $list .= html_writer::end_tag('ul');
1653     echo $list;
1655     return true;
1658 /**
1659  * Return grade for given user or all users.
1660  *
1661  * @global object
1662  * @global object
1663  * @param object $forum
1664  * @param int $userid optional user id, 0 means all users
1665  * @return array array of grades, false if none
1666  */
1667 function forum_get_user_grades($forum, $userid = 0) {
1668     global $CFG;
1670     require_once($CFG->dirroot.'/rating/lib.php');
1672     $ratingoptions = new stdClass;
1673     $ratingoptions->component = 'mod_forum';
1674     $ratingoptions->ratingarea = 'post';
1676     //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?
1677     $ratingoptions->modulename = 'forum';
1678     $ratingoptions->moduleid   = $forum->id;
1679     $ratingoptions->userid = $userid;
1680     $ratingoptions->aggregationmethod = $forum->assessed;
1681     $ratingoptions->scaleid = $forum->scale;
1682     $ratingoptions->itemtable = 'forum_posts';
1683     $ratingoptions->itemtableusercolumn = 'userid';
1685     $rm = new rating_manager();
1686     return $rm->get_user_grades($ratingoptions);
1689 /**
1690  * Update activity grades
1691  *
1692  * @category grade
1693  * @param object $forum
1694  * @param int $userid specific user only, 0 means all
1695  * @param boolean $nullifnone return null if grade does not exist
1696  * @return void
1697  */
1698 function forum_update_grades($forum, $userid=0, $nullifnone=true) {
1699     global $CFG, $DB;
1700     require_once($CFG->libdir.'/gradelib.php');
1702     if (!$forum->assessed) {
1703         forum_grade_item_update($forum);
1705     } else if ($grades = forum_get_user_grades($forum, $userid)) {
1706         forum_grade_item_update($forum, $grades);
1708     } else if ($userid and $nullifnone) {
1709         $grade = new stdClass();
1710         $grade->userid   = $userid;
1711         $grade->rawgrade = NULL;
1712         forum_grade_item_update($forum, $grade);
1714     } else {
1715         forum_grade_item_update($forum);
1716     }
1719 /**
1720  * Create/update grade item for given forum
1721  *
1722  * @category grade
1723  * @uses GRADE_TYPE_NONE
1724  * @uses GRADE_TYPE_VALUE
1725  * @uses GRADE_TYPE_SCALE
1726  * @param stdClass $forum Forum object with extra cmidnumber
1727  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1728  * @return int 0 if ok
1729  */
1730 function forum_grade_item_update($forum, $grades=NULL) {
1731     global $CFG;
1732     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
1733         require_once($CFG->libdir.'/gradelib.php');
1734     }
1736     $params = array('itemname'=>$forum->name, 'idnumber'=>$forum->cmidnumber);
1738     if (!$forum->assessed or $forum->scale == 0) {
1739         $params['gradetype'] = GRADE_TYPE_NONE;
1741     } else if ($forum->scale > 0) {
1742         $params['gradetype'] = GRADE_TYPE_VALUE;
1743         $params['grademax']  = $forum->scale;
1744         $params['grademin']  = 0;
1746     } else if ($forum->scale < 0) {
1747         $params['gradetype'] = GRADE_TYPE_SCALE;
1748         $params['scaleid']   = -$forum->scale;
1749     }
1751     if ($grades  === 'reset') {
1752         $params['reset'] = true;
1753         $grades = NULL;
1754     }
1756     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, $grades, $params);
1759 /**
1760  * Delete grade item for given forum
1761  *
1762  * @category grade
1763  * @param stdClass $forum Forum object
1764  * @return grade_item
1765  */
1766 function forum_grade_item_delete($forum) {
1767     global $CFG;
1768     require_once($CFG->libdir.'/gradelib.php');
1770     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, NULL, array('deleted'=>1));
1774 /**
1775  * This function returns if a scale is being used by one forum
1776  *
1777  * @global object
1778  * @param int $forumid
1779  * @param int $scaleid negative number
1780  * @return bool
1781  */
1782 function forum_scale_used ($forumid,$scaleid) {
1783     global $DB;
1784     $return = false;
1786     $rec = $DB->get_record("forum",array("id" => "$forumid","scale" => "-$scaleid"));
1788     if (!empty($rec) && !empty($scaleid)) {
1789         $return = true;
1790     }
1792     return $return;
1795 /**
1796  * Checks if scale is being used by any instance of forum
1797  *
1798  * This is used to find out if scale used anywhere
1799  *
1800  * @global object
1801  * @param $scaleid int
1802  * @return boolean True if the scale is used by any forum
1803  */
1804 function forum_scale_used_anywhere($scaleid) {
1805     global $DB;
1806     if ($scaleid and $DB->record_exists('forum', array('scale' => -$scaleid))) {
1807         return true;
1808     } else {
1809         return false;
1810     }
1813 // SQL FUNCTIONS ///////////////////////////////////////////////////////////
1815 /**
1816  * Gets a post with all info ready for forum_print_post
1817  * Most of these joins are just to get the forum id
1818  *
1819  * @global object
1820  * @global object
1821  * @param int $postid
1822  * @return mixed array of posts or false
1823  */
1824 function forum_get_post_full($postid) {
1825     global $CFG, $DB;
1827     $allnames = get_all_user_name_fields(true, 'u');
1828     return $DB->get_record_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1829                              FROM {forum_posts} p
1830                                   JOIN {forum_discussions} d ON p.discussion = d.id
1831                                   LEFT JOIN {user} u ON p.userid = u.id
1832                             WHERE p.id = ?", array($postid));
1835 /**
1836  * Gets all posts in discussion including top parent.
1837  *
1838  * @global object
1839  * @global object
1840  * @global object
1841  * @param int $discussionid
1842  * @param string $sort
1843  * @param bool $tracking does user track the forum?
1844  * @return array of posts
1845  */
1846 function forum_get_all_discussion_posts($discussionid, $sort, $tracking=false) {
1847     global $CFG, $DB, $USER;
1849     $tr_sel  = "";
1850     $tr_join = "";
1851     $params = array();
1853     if ($tracking) {
1854         $tr_sel  = ", fr.id AS postread";
1855         $tr_join = "LEFT JOIN {forum_read} fr ON (fr.postid = p.id AND fr.userid = ?)";
1856         $params[] = $USER->id;
1857     }
1859     $allnames = get_all_user_name_fields(true, 'u');
1860     $params[] = $discussionid;
1861     if (!$posts = $DB->get_records_sql("SELECT p.*, $allnames, u.email, u.picture, u.imagealt $tr_sel
1862                                      FROM {forum_posts} p
1863                                           LEFT JOIN {user} u ON p.userid = u.id
1864                                           $tr_join
1865                                     WHERE p.discussion = ?
1866                                  ORDER BY $sort", $params)) {
1867         return array();
1868     }
1870     foreach ($posts as $pid=>$p) {
1871         if ($tracking) {
1872             if (forum_tp_is_post_old($p)) {
1873                  $posts[$pid]->postread = true;
1874             }
1875         }
1876         if (!$p->parent) {
1877             continue;
1878         }
1879         if (!isset($posts[$p->parent])) {
1880             continue; // parent does not exist??
1881         }
1882         if (!isset($posts[$p->parent]->children)) {
1883             $posts[$p->parent]->children = array();
1884         }
1885         $posts[$p->parent]->children[$pid] =& $posts[$pid];
1886     }
1888     // Start with the last child of the first post.
1889     $post = &$posts[reset($posts)->id];
1891     $lastpost = false;
1892     while (!$lastpost) {
1893         if (!isset($post->children)) {
1894             $post->lastpost = true;
1895             $lastpost = true;
1896         } else {
1897              // Go to the last child of this post.
1898             $post = &$posts[end($post->children)->id];
1899         }
1900     }
1902     return $posts;
1905 /**
1906  * An array of forum objects that the user is allowed to read/search through.
1907  *
1908  * @global object
1909  * @global object
1910  * @global object
1911  * @param int $userid
1912  * @param int $courseid if 0, we look for forums throughout the whole site.
1913  * @return array of forum objects, or false if no matches
1914  *         Forum objects have the following attributes:
1915  *         id, type, course, cmid, cmvisible, cmgroupmode, accessallgroups,
1916  *         viewhiddentimedposts
1917  */
1918 function forum_get_readable_forums($userid, $courseid=0) {
1920     global $CFG, $DB, $USER;
1921     require_once($CFG->dirroot.'/course/lib.php');
1923     if (!$forummod = $DB->get_record('modules', array('name' => 'forum'))) {
1924         print_error('notinstalled', 'forum');
1925     }
1927     if ($courseid) {
1928         $courses = $DB->get_records('course', array('id' => $courseid));
1929     } else {
1930         // If no course is specified, then the user can see SITE + his courses.
1931         $courses1 = $DB->get_records('course', array('id' => SITEID));
1932         $courses2 = enrol_get_users_courses($userid, true, array('modinfo'));
1933         $courses = array_merge($courses1, $courses2);
1934     }
1935     if (!$courses) {
1936         return array();
1937     }
1939     $readableforums = array();
1941     foreach ($courses as $course) {
1943         $modinfo = get_fast_modinfo($course);
1945         if (empty($modinfo->instances['forum'])) {
1946             // hmm, no forums?
1947             continue;
1948         }
1950         $courseforums = $DB->get_records('forum', array('course' => $course->id));
1952         foreach ($modinfo->instances['forum'] as $forumid => $cm) {
1953             if (!$cm->uservisible or !isset($courseforums[$forumid])) {
1954                 continue;
1955             }
1956             $context = context_module::instance($cm->id);
1957             $forum = $courseforums[$forumid];
1958             $forum->context = $context;
1959             $forum->cm = $cm;
1961             if (!has_capability('mod/forum:viewdiscussion', $context)) {
1962                 continue;
1963             }
1965          /// group access
1966             if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
1968                 $forum->onlygroups = $modinfo->get_groups($cm->groupingid);
1969                 $forum->onlygroups[] = -1;
1970             }
1972         /// hidden timed discussions
1973             $forum->viewhiddentimedposts = true;
1974             if (!empty($CFG->forum_enabletimedposts)) {
1975                 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1976                     $forum->viewhiddentimedposts = false;
1977                 }
1978             }
1980         /// qanda access
1981             if ($forum->type == 'qanda'
1982                     && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
1984                 // We need to check whether the user has posted in the qanda forum.
1985                 $forum->onlydiscussions = array();  // Holds discussion ids for the discussions
1986                                                     // the user is allowed to see in this forum.
1987                 if ($discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $USER->id)) {
1988                     foreach ($discussionspostedin as $d) {
1989                         $forum->onlydiscussions[] = $d->id;
1990                     }
1991                 }
1992             }
1994             $readableforums[$forum->id] = $forum;
1995         }
1997         unset($modinfo);
1999     } // End foreach $courses
2001     return $readableforums;
2004 /**
2005  * Returns a list of posts found using an array of search terms.
2006  *
2007  * @global object
2008  * @global object
2009  * @global object
2010  * @param array $searchterms array of search terms, e.g. word +word -word
2011  * @param int $courseid if 0, we search through the whole site
2012  * @param int $limitfrom
2013  * @param int $limitnum
2014  * @param int &$totalcount
2015  * @param string $extrasql
2016  * @return array|bool Array of posts found or false
2017  */
2018 function forum_search_posts($searchterms, $courseid=0, $limitfrom=0, $limitnum=50,
2019                             &$totalcount, $extrasql='') {
2020     global $CFG, $DB, $USER;
2021     require_once($CFG->libdir.'/searchlib.php');
2023     $forums = forum_get_readable_forums($USER->id, $courseid);
2025     if (count($forums) == 0) {
2026         $totalcount = 0;
2027         return false;
2028     }
2030     $now = floor(time() / 60) * 60; // DB Cache Friendly.
2032     $fullaccess = array();
2033     $where = array();
2034     $params = array();
2036     foreach ($forums as $forumid => $forum) {
2037         $select = array();
2039         if (!$forum->viewhiddentimedposts) {
2040             $select[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
2041             $params = array_merge($params, array('userid'.$forumid=>$USER->id, 'timestart'.$forumid=>$now, 'timeend'.$forumid=>$now));
2042         }
2044         $cm = $forum->cm;
2045         $context = $forum->context;
2047         if ($forum->type == 'qanda'
2048             && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
2049             if (!empty($forum->onlydiscussions)) {
2050                 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forum->onlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
2051                 $params = array_merge($params, $discussionid_params);
2052                 $select[] = "(d.id $discussionid_sql OR p.parent = 0)";
2053             } else {
2054                 $select[] = "p.parent = 0";
2055             }
2056         }
2058         if (!empty($forum->onlygroups)) {
2059             list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($forum->onlygroups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
2060             $params = array_merge($params, $groupid_params);
2061             $select[] = "d.groupid $groupid_sql";
2062         }
2064         if ($select) {
2065             $selects = implode(" AND ", $select);
2066             $where[] = "(d.forum = :forum{$forumid} AND $selects)";
2067             $params['forum'.$forumid] = $forumid;
2068         } else {
2069             $fullaccess[] = $forumid;
2070         }
2071     }
2073     if ($fullaccess) {
2074         list($fullid_sql, $fullid_params) = $DB->get_in_or_equal($fullaccess, SQL_PARAMS_NAMED, 'fula');
2075         $params = array_merge($params, $fullid_params);
2076         $where[] = "(d.forum $fullid_sql)";
2077     }
2079     $selectdiscussion = "(".implode(" OR ", $where).")";
2081     $messagesearch = '';
2082     $searchstring = '';
2084     // Need to concat these back together for parser to work.
2085     foreach($searchterms as $searchterm){
2086         if ($searchstring != '') {
2087             $searchstring .= ' ';
2088         }
2089         $searchstring .= $searchterm;
2090     }
2092     // We need to allow quoted strings for the search. The quotes *should* be stripped
2093     // by the parser, but this should be examined carefully for security implications.
2094     $searchstring = str_replace("\\\"","\"",$searchstring);
2095     $parser = new search_parser();
2096     $lexer = new search_lexer($parser);
2098     if ($lexer->parse($searchstring)) {
2099         $parsearray = $parser->get_parsed_array();
2101         $tagjoins = '';
2102         $tagfields = [];
2103         $tagfieldcount = 0;
2104         foreach ($parsearray as $token) {
2105             if ($token->getType() == TOKEN_TAGS) {
2106                 for ($i = 0; $i <= substr_count($token->getValue(), ','); $i++) {
2107                     // Queries can only have a limited number of joins so set a limit sensible users won't exceed.
2108                     if ($tagfieldcount > 10) {
2109                         continue;
2110                     }
2111                     $tagjoins .= " LEFT JOIN {tag_instance} ti_$tagfieldcount
2112                                         ON p.id = ti_$tagfieldcount.itemid
2113                                             AND ti_$tagfieldcount.component = 'mod_forum'
2114                                             AND ti_$tagfieldcount.itemtype = 'forum_posts'";
2115                     $tagjoins .= " LEFT JOIN {tag} t_$tagfieldcount ON t_$tagfieldcount.id = ti_$tagfieldcount.tagid";
2116                     $tagfields[] = "t_$tagfieldcount.rawname";
2117                     $tagfieldcount++;
2118                 }
2119             }
2120         }
2121         list($messagesearch, $msparams) = search_generate_SQL($parsearray, 'p.message', 'p.subject',
2122                                                               'p.userid', 'u.id', 'u.firstname',
2123                                                               'u.lastname', 'p.modified', 'd.forum',
2124                                                               $tagfields);
2125         $params = array_merge($params, $msparams);
2126     }
2128     $fromsql = "{forum_posts} p
2129                   INNER JOIN {forum_discussions} d ON d.id = p.discussion
2130                   INNER JOIN {user} u ON u.id = p.userid $tagjoins";
2132     $selectsql = " $messagesearch
2133                AND p.discussion = d.id
2134                AND p.userid = u.id
2135                AND $selectdiscussion
2136                    $extrasql";
2138     $countsql = "SELECT COUNT(*)
2139                    FROM $fromsql
2140                   WHERE $selectsql";
2142     $allnames = get_all_user_name_fields(true, 'u');
2143     $searchsql = "SELECT p.*,
2144                          d.forum,
2145                          $allnames,
2146                          u.email,
2147                          u.picture,
2148                          u.imagealt
2149                     FROM $fromsql
2150                    WHERE $selectsql
2151                 ORDER BY p.modified DESC";
2153     $totalcount = $DB->count_records_sql($countsql, $params);
2155     return $DB->get_records_sql($searchsql, $params, $limitfrom, $limitnum);
2158 /**
2159  * Returns a list of all new posts that have not been mailed yet
2160  *
2161  * @param int $starttime posts created after this time
2162  * @param int $endtime posts created before this
2163  * @param int $now used for timed discussions only
2164  * @return array
2165  */
2166 function forum_get_unmailed_posts($starttime, $endtime, $now=null) {
2167     global $CFG, $DB;
2169     $params = array();
2170     $params['mailed'] = FORUM_MAILED_PENDING;
2171     $params['ptimestart'] = $starttime;
2172     $params['ptimeend'] = $endtime;
2173     $params['mailnow'] = 1;
2175     if (!empty($CFG->forum_enabletimedposts)) {
2176         if (empty($now)) {
2177             $now = time();
2178         }
2179         $selectsql = "AND (p.created >= :ptimestart OR d.timestart >= :pptimestart)";
2180         $params['pptimestart'] = $starttime;
2181         $timedsql = "AND (d.timestart < :dtimestart AND (d.timeend = 0 OR d.timeend > :dtimeend))";
2182         $params['dtimestart'] = $now;
2183         $params['dtimeend'] = $now;
2184     } else {
2185         $timedsql = "";
2186         $selectsql = "AND p.created >= :ptimestart";
2187     }
2189     return $DB->get_records_sql("SELECT p.*, d.course, d.forum
2190                                  FROM {forum_posts} p
2191                                  JOIN {forum_discussions} d ON d.id = p.discussion
2192                                  WHERE p.mailed = :mailed
2193                                  $selectsql
2194                                  AND (p.created < :ptimeend OR p.mailnow = :mailnow)
2195                                  $timedsql
2196                                  ORDER BY p.modified ASC", $params);
2199 /**
2200  * Marks posts before a certain time as being mailed already
2201  *
2202  * @global object
2203  * @global object
2204  * @param int $endtime
2205  * @param int $now Defaults to time()
2206  * @return bool
2207  */
2208 function forum_mark_old_posts_as_mailed($endtime, $now=null) {
2209     global $CFG, $DB;
2211     if (empty($now)) {
2212         $now = time();
2213     }
2215     $params = array();
2216     $params['mailedsuccess'] = FORUM_MAILED_SUCCESS;
2217     $params['now'] = $now;
2218     $params['endtime'] = $endtime;
2219     $params['mailnow'] = 1;
2220     $params['mailedpending'] = FORUM_MAILED_PENDING;
2222     if (empty($CFG->forum_enabletimedposts)) {
2223         return $DB->execute("UPDATE {forum_posts}
2224                              SET mailed = :mailedsuccess
2225                              WHERE (created < :endtime OR mailnow = :mailnow)
2226                              AND mailed = :mailedpending", $params);
2227     } else {
2228         return $DB->execute("UPDATE {forum_posts}
2229                              SET mailed = :mailedsuccess
2230                              WHERE discussion NOT IN (SELECT d.id
2231                                                       FROM {forum_discussions} d
2232                                                       WHERE d.timestart > :now)
2233                              AND (created < :endtime OR mailnow = :mailnow)
2234                              AND mailed = :mailedpending", $params);
2235     }
2238 /**
2239  * Get all the posts for a user in a forum suitable for forum_print_post
2240  *
2241  * @global object
2242  * @global object
2243  * @uses CONTEXT_MODULE
2244  * @return array
2245  */
2246 function forum_get_user_posts($forumid, $userid) {
2247     global $CFG, $DB;
2249     $timedsql = "";
2250     $params = array($forumid, $userid);
2252     if (!empty($CFG->forum_enabletimedposts)) {
2253         $cm = get_coursemodule_from_instance('forum', $forumid);
2254         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2255             $now = time();
2256             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2257             $params[] = $now;
2258             $params[] = $now;
2259         }
2260     }
2262     $allnames = get_all_user_name_fields(true, 'u');
2263     return $DB->get_records_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
2264                               FROM {forum} f
2265                                    JOIN {forum_discussions} d ON d.forum = f.id
2266                                    JOIN {forum_posts} p       ON p.discussion = d.id
2267                                    JOIN {user} u              ON u.id = p.userid
2268                              WHERE f.id = ?
2269                                    AND p.userid = ?
2270                                    $timedsql
2271                           ORDER BY p.modified ASC", $params);
2274 /**
2275  * Get all the discussions user participated in
2276  *
2277  * @global object
2278  * @global object
2279  * @uses CONTEXT_MODULE
2280  * @param int $forumid
2281  * @param int $userid
2282  * @return array Array or false
2283  */
2284 function forum_get_user_involved_discussions($forumid, $userid) {
2285     global $CFG, $DB;
2287     $timedsql = "";
2288     $params = array($forumid, $userid);
2289     if (!empty($CFG->forum_enabletimedposts)) {
2290         $cm = get_coursemodule_from_instance('forum', $forumid);
2291         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2292             $now = time();
2293             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2294             $params[] = $now;
2295             $params[] = $now;
2296         }
2297     }
2299     return $DB->get_records_sql("SELECT DISTINCT d.*
2300                               FROM {forum} f
2301                                    JOIN {forum_discussions} d ON d.forum = f.id
2302                                    JOIN {forum_posts} p       ON p.discussion = d.id
2303                              WHERE f.id = ?
2304                                    AND p.userid = ?
2305                                    $timedsql", $params);
2308 /**
2309  * Get all the posts for a user in a forum suitable for forum_print_post
2310  *
2311  * @global object
2312  * @global object
2313  * @param int $forumid
2314  * @param int $userid
2315  * @return array of counts or false
2316  */
2317 function forum_count_user_posts($forumid, $userid) {
2318     global $CFG, $DB;
2320     $timedsql = "";
2321     $params = array($forumid, $userid);
2322     if (!empty($CFG->forum_enabletimedposts)) {
2323         $cm = get_coursemodule_from_instance('forum', $forumid);
2324         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2325             $now = time();
2326             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2327             $params[] = $now;
2328             $params[] = $now;
2329         }
2330     }
2332     return $DB->get_record_sql("SELECT COUNT(p.id) AS postcount, MAX(p.modified) AS lastpost
2333                              FROM {forum} f
2334                                   JOIN {forum_discussions} d ON d.forum = f.id
2335                                   JOIN {forum_posts} p       ON p.discussion = d.id
2336                                   JOIN {user} u              ON u.id = p.userid
2337                             WHERE f.id = ?
2338                                   AND p.userid = ?
2339                                   $timedsql", $params);
2342 /**
2343  * Given a log entry, return the forum post details for it.
2344  *
2345  * @global object
2346  * @global object
2347  * @param object $log
2348  * @return array|null
2349  */
2350 function forum_get_post_from_log($log) {
2351     global $CFG, $DB;
2353     $allnames = get_all_user_name_fields(true, 'u');
2354     if ($log->action == "add post") {
2356         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2357                                  FROM {forum_discussions} d,
2358                                       {forum_posts} p,
2359                                       {forum} f,
2360                                       {user} u
2361                                 WHERE p.id = ?
2362                                   AND d.id = p.discussion
2363                                   AND p.userid = u.id
2364                                   AND u.deleted <> '1'
2365                                   AND f.id = d.forum", array($log->info));
2368     } else if ($log->action == "add discussion") {
2370         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2371                                  FROM {forum_discussions} d,
2372                                       {forum_posts} p,
2373                                       {forum} f,
2374                                       {user} u
2375                                 WHERE d.id = ?
2376                                   AND d.firstpost = p.id
2377                                   AND p.userid = u.id
2378                                   AND u.deleted <> '1'
2379                                   AND f.id = d.forum", array($log->info));
2380     }
2381     return NULL;
2384 /**
2385  * Given a discussion id, return the first post from the discussion
2386  *
2387  * @global object
2388  * @global object
2389  * @param int $dicsussionid
2390  * @return array
2391  */
2392 function forum_get_firstpost_from_discussion($discussionid) {
2393     global $CFG, $DB;
2395     return $DB->get_record_sql("SELECT p.*
2396                              FROM {forum_discussions} d,
2397                                   {forum_posts} p
2398                             WHERE d.id = ?
2399                               AND d.firstpost = p.id ", array($discussionid));
2402 /**
2403  * Returns an array of counts of replies to each discussion
2404  *
2405  * @global object
2406  * @global object
2407  * @param int $forumid
2408  * @param string $forumsort
2409  * @param int $limit
2410  * @param int $page
2411  * @param int $perpage
2412  * @return array
2413  */
2414 function forum_count_discussion_replies($forumid, $forumsort="", $limit=-1, $page=-1, $perpage=0) {
2415     global $CFG, $DB;
2417     if ($limit > 0) {
2418         $limitfrom = 0;
2419         $limitnum  = $limit;
2420     } else if ($page != -1) {
2421         $limitfrom = $page*$perpage;
2422         $limitnum  = $perpage;
2423     } else {
2424         $limitfrom = 0;
2425         $limitnum  = 0;
2426     }
2428     if ($forumsort == "") {
2429         $orderby = "";
2430         $groupby = "";
2432     } else {
2433         $orderby = "ORDER BY $forumsort";
2434         $groupby = ", ".strtolower($forumsort);
2435         $groupby = str_replace('desc', '', $groupby);
2436         $groupby = str_replace('asc', '', $groupby);
2437     }
2439     if (($limitfrom == 0 and $limitnum == 0) or $forumsort == "") {
2440         $sql = "SELECT p.discussion, COUNT(p.id) AS replies, MAX(p.id) AS lastpostid
2441                   FROM {forum_posts} p
2442                        JOIN {forum_discussions} d ON p.discussion = d.id
2443                  WHERE p.parent > 0 AND d.forum = ?
2444               GROUP BY p.discussion";
2445         return $DB->get_records_sql($sql, array($forumid));
2447     } else {
2448         $sql = "SELECT p.discussion, (COUNT(p.id) - 1) AS replies, MAX(p.id) AS lastpostid
2449                   FROM {forum_posts} p
2450                        JOIN {forum_discussions} d ON p.discussion = d.id
2451                  WHERE d.forum = ?
2452               GROUP BY p.discussion $groupby $orderby";
2453         return $DB->get_records_sql($sql, array($forumid), $limitfrom, $limitnum);
2454     }
2457 /**
2458  * @global object
2459  * @global object
2460  * @global object
2461  * @staticvar array $cache
2462  * @param object $forum
2463  * @param object $cm
2464  * @param object $course
2465  * @return mixed
2466  */
2467 function forum_count_discussions($forum, $cm, $course) {
2468     global $CFG, $DB, $USER;
2470     static $cache = array();
2472     $now = floor(time() / 60) * 60; // DB Cache Friendly.
2474     $params = array($course->id);
2476     if (!isset($cache[$course->id])) {
2477         if (!empty($CFG->forum_enabletimedposts)) {
2478             $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
2479             $params[] = $now;
2480             $params[] = $now;
2481         } else {
2482             $timedsql = "";
2483         }
2485         $sql = "SELECT f.id, COUNT(d.id) as dcount
2486                   FROM {forum} f
2487                        JOIN {forum_discussions} d ON d.forum = f.id
2488                  WHERE f.course = ?
2489                        $timedsql
2490               GROUP BY f.id";
2492         if ($counts = $DB->get_records_sql($sql, $params)) {
2493             foreach ($counts as $count) {
2494                 $counts[$count->id] = $count->dcount;
2495             }
2496             $cache[$course->id] = $counts;
2497         } else {
2498             $cache[$course->id] = array();
2499         }
2500     }
2502     if (empty($cache[$course->id][$forum->id])) {
2503         return 0;
2504     }
2506     $groupmode = groups_get_activity_groupmode($cm, $course);
2508     if ($groupmode != SEPARATEGROUPS) {
2509         return $cache[$course->id][$forum->id];
2510     }
2512     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
2513         return $cache[$course->id][$forum->id];
2514     }
2516     require_once($CFG->dirroot.'/course/lib.php');
2518     $modinfo = get_fast_modinfo($course);
2520     $mygroups = $modinfo->get_groups($cm->groupingid);
2522     // add all groups posts
2523     $mygroups[-1] = -1;
2525     list($mygroups_sql, $params) = $DB->get_in_or_equal($mygroups);
2526     $params[] = $forum->id;
2528     if (!empty($CFG->forum_enabletimedposts)) {
2529         $timedsql = "AND d.timestart < $now AND (d.timeend = 0 OR d.timeend > $now)";
2530         $params[] = $now;
2531         $params[] = $now;
2532     } else {
2533         $timedsql = "";
2534     }
2536     $sql = "SELECT COUNT(d.id)
2537               FROM {forum_discussions} d
2538              WHERE d.groupid $mygroups_sql AND d.forum = ?
2539                    $timedsql";
2541     return $DB->get_field_sql($sql, $params);
2544 /**
2545  * Get all discussions in a forum
2546  *
2547  * @global object
2548  * @global object
2549  * @global object
2550  * @uses CONTEXT_MODULE
2551  * @uses VISIBLEGROUPS
2552  * @param object $cm
2553  * @param string $forumsort
2554  * @param bool $fullpost
2555  * @param int $unused
2556  * @param int $limit
2557  * @param bool $userlastmodified
2558  * @param int $page
2559  * @param int $perpage
2560  * @param int $groupid if groups enabled, get discussions for this group overriding the current group.
2561  *                     Use FORUM_POSTS_ALL_USER_GROUPS for all the user groups
2562  * @param int $updatedsince retrieve only discussions updated since the given time
2563  * @return array
2564  */
2565 function forum_get_discussions($cm, $forumsort="", $fullpost=true, $unused=-1, $limit=-1,
2566                                 $userlastmodified=false, $page=-1, $perpage=0, $groupid = -1,
2567                                 $updatedsince = 0) {
2568     global $CFG, $DB, $USER;
2570     $timelimit = '';
2572     $now = floor(time() / 60) * 60;
2573     $params = array($cm->instance);
2575     $modcontext = context_module::instance($cm->id);
2577     if (!has_capability('mod/forum:viewdiscussion', $modcontext)) { /// User must have perms to view discussions
2578         return array();
2579     }
2581     if (!empty($CFG->forum_enabletimedposts)) { /// Users must fulfill timed posts
2583         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2584             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2585             $params[] = $now;
2586             $params[] = $now;
2587             if (isloggedin()) {
2588                 $timelimit .= " OR d.userid = ?";
2589                 $params[] = $USER->id;
2590             }
2591             $timelimit .= ")";
2592         }
2593     }
2595     if ($limit > 0) {
2596         $limitfrom = 0;
2597         $limitnum  = $limit;
2598     } else if ($page != -1) {
2599         $limitfrom = $page*$perpage;
2600         $limitnum  = $perpage;
2601     } else {
2602         $limitfrom = 0;
2603         $limitnum  = 0;
2604     }
2606     $groupmode    = groups_get_activity_groupmode($cm);
2608     if ($groupmode) {
2610         if (empty($modcontext)) {
2611             $modcontext = context_module::instance($cm->id);
2612         }
2614         // Special case, we received a groupid to override currentgroup.
2615         if ($groupid > 0) {
2616             $course = get_course($cm->course);
2617             if (!groups_group_visible($groupid, $course, $cm)) {
2618                 // User doesn't belong to this group, return nothing.
2619                 return array();
2620             }
2621             $currentgroup = $groupid;
2622         } else if ($groupid === -1) {
2623             $currentgroup = groups_get_activity_group($cm);
2624         } else {
2625             // Get discussions for all groups current user can see.
2626             $currentgroup = null;
2627         }
2629         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2630             if ($currentgroup) {
2631                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2632                 $params[] = $currentgroup;
2633             } else {
2634                 $groupselect = "";
2635             }
2637         } else {
2638             // Separate groups.
2640             // Get discussions for all groups current user can see.
2641             if ($currentgroup === null) {
2642                 $mygroups = array_keys(groups_get_all_groups($cm->course, $USER->id, $cm->groupingid, 'g.id'));
2643                 if (empty($mygroups)) {
2644                      $groupselect = "AND d.groupid = -1";
2645                 } else {
2646                     list($insqlgroups, $inparamsgroups) = $DB->get_in_or_equal($mygroups);
2647                     $groupselect = "AND (d.groupid = -1 OR d.groupid $insqlgroups)";
2648                     $params = array_merge($params, $inparamsgroups);
2649                 }
2650             } else if ($currentgroup) {
2651                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2652                 $params[] = $currentgroup;
2653             } else {
2654                 $groupselect = "AND d.groupid = -1";
2655             }
2656         }
2657     } else {
2658         $groupselect = "";
2659     }
2660     if (empty($forumsort)) {
2661         $forumsort = forum_get_default_sort_order();
2662     }
2663     if (empty($fullpost)) {
2664         $postdata = "p.id, p.subject, p.modified, p.discussion, p.userid, p.created";
2665     } else {
2666         $postdata = "p.*";
2667     }
2669     if (empty($userlastmodified)) {  // We don't need to know this
2670         $umfields = "";
2671         $umtable  = "";
2672     } else {
2673         $umfields = ', ' . get_all_user_name_fields(true, 'um', null, 'um') . ', um.email AS umemail, um.picture AS umpicture,
2674                         um.imagealt AS umimagealt';
2675         $umtable  = " LEFT JOIN {user} um ON (d.usermodified = um.id)";
2676     }
2678     $updatedsincesql = '';
2679     if (!empty($updatedsince)) {
2680         $updatedsincesql = 'AND d.timemodified > ?';
2681         $params[] = $updatedsince;
2682     }
2684     $allnames = get_all_user_name_fields(true, 'u');
2685     $sql = "SELECT $postdata, d.name, d.timemodified, d.usermodified, d.groupid, d.timestart, d.timeend, d.pinned,
2686                    $allnames, u.email, u.picture, u.imagealt $umfields
2687               FROM {forum_discussions} d
2688                    JOIN {forum_posts} p ON p.discussion = d.id
2689                    JOIN {user} u ON p.userid = u.id
2690                    $umtable
2691              WHERE d.forum = ? AND p.parent = 0
2692                    $timelimit $groupselect $updatedsincesql
2693           ORDER BY $forumsort, d.id DESC";
2695     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
2698 /**
2699  * Gets the neighbours (previous and next) of a discussion.
2700  *
2701  * The calculation is based on the timemodified when time modified or time created is identical
2702  * It will revert to using the ID to sort consistently. This is better tha skipping a discussion.
2703  *
2704  * For blog-style forums, the calculation is based on the original creation time of the
2705  * blog post.
2706  *
2707  * Please note that this does not check whether or not the discussion passed is accessible
2708  * by the user, it simply uses it as a reference to find the neighbours. On the other hand,
2709  * the returned neighbours are checked and are accessible to the current user.
2710  *
2711  * @param object $cm The CM record.
2712  * @param object $discussion The discussion record.
2713  * @param object $forum The forum instance record.
2714  * @return array That always contains the keys 'prev' and 'next'. When there is a result
2715  *               they contain the record with minimal information such as 'id' and 'name'.
2716  *               When the neighbour is not found the value is false.
2717  */
2718 function forum_get_discussion_neighbours($cm, $discussion, $forum) {
2719     global $CFG, $DB, $USER;
2721     if ($cm->instance != $discussion->forum or $discussion->forum != $forum->id or $forum->id != $cm->instance) {
2722         throw new coding_exception('Discussion is not part of the same forum.');
2723     }
2725     $neighbours = array('prev' => false, 'next' => false);
2726     $now = floor(time() / 60) * 60;
2727     $params = array();
2729     $modcontext = context_module::instance($cm->id);
2730     $groupmode    = groups_get_activity_groupmode($cm);
2731     $currentgroup = groups_get_activity_group($cm);
2733     // Users must fulfill timed posts.
2734     $timelimit = '';
2735     if (!empty($CFG->forum_enabletimedposts)) {
2736         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2737             $timelimit = ' AND ((d.timestart <= :tltimestart AND (d.timeend = 0 OR d.timeend > :tltimeend))';
2738             $params['tltimestart'] = $now;
2739             $params['tltimeend'] = $now;
2740             if (isloggedin()) {
2741                 $timelimit .= ' OR d.userid = :tluserid';
2742                 $params['tluserid'] = $USER->id;
2743             }
2744             $timelimit .= ')';
2745         }
2746     }
2748     // Limiting to posts accessible according to groups.
2749     $groupselect = '';
2750     if ($groupmode) {
2751         if ($groupmode == VISIBLEGROUPS || has_capability('moodle/site:accessallgroups', $modcontext)) {
2752             if ($currentgroup) {
2753                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2754                 $params['groupid'] = $currentgroup;
2755             }
2756         } else {
2757             if ($currentgroup) {
2758                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2759                 $params['groupid'] = $currentgroup;
2760             } else {
2761                 $groupselect = 'AND d.groupid = -1';
2762             }
2763         }
2764     }
2766     $params['forumid'] = $cm->instance;
2767     $params['discid1'] = $discussion->id;
2768     $params['discid2'] = $discussion->id;
2769     $params['discid3'] = $discussion->id;
2770     $params['discid4'] = $discussion->id;
2771     $params['disctimecompare1'] = $discussion->timemodified;
2772     $params['disctimecompare2'] = $discussion->timemodified;
2773     $params['pinnedstate1'] = (int) $discussion->pinned;
2774     $params['pinnedstate2'] = (int) $discussion->pinned;
2775     $params['pinnedstate3'] = (int) $discussion->pinned;
2776     $params['pinnedstate4'] = (int) $discussion->pinned;
2778     $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
2779               FROM {forum_discussions} d
2780               JOIN {forum_posts} p ON d.firstpost = p.id
2781              WHERE d.forum = :forumid
2782                AND d.id <> :discid1
2783                    $timelimit
2784                    $groupselect";
2785     $comparefield = "d.timemodified";
2786     $comparevalue = ":disctimecompare1";
2787     $comparevalue2  = ":disctimecompare2";
2788     if (!empty($CFG->forum_enabletimedposts)) {
2789         // Here we need to take into account the release time (timestart)
2790         // if one is set, of the neighbouring posts and compare it to the
2791         // timestart or timemodified of *this* post depending on if the
2792         // release date of this post is in the future or not.
2793         // This stops discussions that appear later because of the
2794         // timestart value from being buried under discussions that were
2795         // made afterwards.
2796         $comparefield = "CASE WHEN d.timemodified < d.timestart
2797                                 THEN d.timestart ELSE d.timemodified END";
2798         if ($discussion->timemodified < $discussion->timestart) {
2799             // Normally we would just use the timemodified for sorting
2800             // discussion posts. However, when timed discussions are enabled,
2801             // then posts need to be sorted base on the later of timemodified
2802             // or the release date of the post (timestart).
2803             $params['disctimecompare1'] = $discussion->timestart;
2804             $params['disctimecompare2'] = $discussion->timestart;
2805         }
2806     }
2807     $orderbydesc = forum_get_default_sort_order(true, $comparefield, 'd', false);
2808     $orderbyasc = forum_get_default_sort_order(false, $comparefield, 'd', false);
2810     if ($forum->type === 'blog') {
2811          $subselect = "SELECT pp.created
2812                    FROM {forum_discussions} dd
2813                    JOIN {forum_posts} pp ON dd.firstpost = pp.id ";
2815          $subselectwhere1 = " WHERE dd.id = :discid3";
2816          $subselectwhere2 = " WHERE dd.id = :discid4";
2818          $comparefield = "p.created";
2820          $sub1 = $subselect.$subselectwhere1;
2821          $comparevalue = "($sub1)";
2823          $sub2 = $subselect.$subselectwhere2;
2824          $comparevalue2 = "($sub2)";
2826          $orderbydesc = "d.pinned, p.created DESC";
2827          $orderbyasc = "d.pinned, p.created ASC";
2828     }
2830     $prevsql = $sql . " AND ( (($comparefield < $comparevalue) AND :pinnedstate1 = d.pinned)
2831                          OR ($comparefield = $comparevalue2 AND (d.pinned = 0 OR d.pinned = :pinnedstate4) AND d.id < :discid2)
2832                          OR (d.pinned = 0 AND d.pinned <> :pinnedstate2))
2833                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbydesc, d.id DESC";
2835     $nextsql = $sql . " AND ( (($comparefield > $comparevalue) AND :pinnedstate1 = d.pinned)
2836                          OR ($comparefield = $comparevalue2 AND (d.pinned = 1 OR d.pinned = :pinnedstate4) AND d.id > :discid2)
2837                          OR (d.pinned = 1 AND d.pinned <> :pinnedstate2))
2838                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbyasc, d.id ASC";
2840     $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
2841     $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
2842     return $neighbours;
2845 /**
2846  * Get the sql to use in the ORDER BY clause for forum discussions.
2847  *
2848  * This has the ordering take timed discussion windows into account.
2849  *
2850  * @param bool $desc True for DESC, False for ASC.
2851  * @param string $compare The field in the SQL to compare to normally sort by.
2852  * @param string $prefix The prefix being used for the discussion table.
2853  * @param bool $pinned sort pinned posts to the top
2854  * @return string
2855  */
2856 function forum_get_default_sort_order($desc = true, $compare = 'd.timemodified', $prefix = 'd', $pinned = true) {
2857     global $CFG;
2859     if (!empty($prefix)) {
2860         $prefix .= '.';
2861     }
2863     $dir = $desc ? 'DESC' : 'ASC';
2865     if ($pinned == true) {
2866         $pinned = "{$prefix}pinned DESC,";
2867     } else {
2868         $pinned = '';
2869     }
2871     $sort = "{$prefix}timemodified";
2872     if (!empty($CFG->forum_enabletimedposts)) {
2873         $sort = "CASE WHEN {$compare} < {$prefix}timestart
2874                  THEN {$prefix}timestart
2875                  ELSE {$compare}
2876                  END";
2877     }
2878     return "$pinned $sort $dir";
2881 /**
2882  *
2883  * @global object
2884  * @global object
2885  * @global object
2886  * @uses CONTEXT_MODULE
2887  * @uses VISIBLEGROUPS
2888  * @param object $cm
2889  * @return array
2890  */
2891 function forum_get_discussions_unread($cm) {
2892     global $CFG, $DB, $USER;
2894     $now = floor(time() / 60) * 60;
2895     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2897     $params = array();
2898     $groupmode    = groups_get_activity_groupmode($cm);
2899     $currentgroup = groups_get_activity_group($cm);
2901     if ($groupmode) {
2902         $modcontext = context_module::instance($cm->id);
2904         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2905             if ($currentgroup) {
2906                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2907                 $params['currentgroup'] = $currentgroup;
2908             } else {
2909                 $groupselect = "";
2910             }
2912         } else {
2913             //separate groups without access all
2914             if ($currentgroup) {
2915                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2916                 $params['currentgroup'] = $currentgroup;
2917             } else {
2918                 $groupselect = "AND d.groupid = -1";
2919             }
2920         }
2921     } else {
2922         $groupselect = "";
2923     }
2925     if (!empty($CFG->forum_enabletimedposts)) {
2926         $timedsql = "AND d.timestart < :now1 AND (d.timeend = 0 OR d.timeend > :now2)";
2927         $params['now1'] = $now;
2928         $params['now2'] = $now;
2929     } else {
2930         $timedsql = "";
2931     }
2933     $sql = "SELECT d.id, COUNT(p.id) AS unread
2934               FROM {forum_discussions} d
2935                    JOIN {forum_posts} p     ON p.discussion = d.id
2936                    LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = $USER->id)
2937              WHERE d.forum = {$cm->instance}
2938                    AND p.modified >= :cutoffdate AND r.id is NULL
2939                    $groupselect
2940                    $timedsql
2941           GROUP BY d.id";
2942     $params['cutoffdate'] = $cutoffdate;
2944     if ($unreads = $DB->get_records_sql($sql, $params)) {
2945         foreach ($unreads as $unread) {
2946             $unreads[$unread->id] = $unread->unread;
2947         }
2948         return $unreads;
2949     } else {
2950         return array();
2951     }
2954 /**
2955  * @global object
2956  * @global object
2957  * @global object
2958  * @uses CONEXT_MODULE
2959  * @uses VISIBLEGROUPS
2960  * @param object $cm
2961  * @return array
2962  */
2963 function forum_get_discussions_count($cm) {
2964     global $CFG, $DB, $USER;
2966     $now = floor(time() / 60) * 60;
2967     $params = array($cm->instance);
2968     $groupmode    = groups_get_activity_groupmode($cm);
2969     $currentgroup = groups_get_activity_group($cm);
2971     if ($groupmode) {
2972         $modcontext = context_module::instance($cm->id);
2974         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2975             if ($currentgroup) {
2976                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2977                 $params[] = $currentgroup;
2978             } else {
2979                 $groupselect = "";
2980             }
2982         } else {
2983             //seprate groups without access all
2984             if ($currentgroup) {
2985                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2986                 $params[] = $currentgroup;
2987             } else {
2988                 $groupselect = "AND d.groupid = -1";
2989             }
2990         }
2991     } else {
2992         $groupselect = "";
2993     }
2995     $timelimit = "";
2997     if (!empty($CFG->forum_enabletimedposts)) {
2999         $modcontext = context_module::instance($cm->id);
3001         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
3002             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
3003             $params[] = $now;
3004             $params[] = $now;
3005             if (isloggedin()) {
3006                 $timelimit .= " OR d.userid = ?";
3007                 $params[] = $USER->id;
3008             }
3009             $timelimit .= ")";
3010         }
3011     }
3013     $sql = "SELECT COUNT(d.id)
3014               FROM {forum_discussions} d
3015                    JOIN {forum_posts} p ON p.discussion = d.id
3016              WHERE d.forum = ? AND p.parent = 0
3017                    $groupselect $timelimit";
3019     return $DB->get_field_sql($sql, $params);
3023 // OTHER FUNCTIONS ///////////////////////////////////////////////////////////
3026 /**
3027  * @global object
3028  * @global object
3029  * @param int $courseid
3030  * @param string $type
3031  */
3032 function forum_get_course_forum($courseid, $type) {
3033 // How to set up special 1-per-course forums
3034     global $CFG, $DB, $OUTPUT, $USER;
3036     if ($forums = $DB->get_records_select("forum", "course = ? AND type = ?", array($courseid, $type), "id ASC")) {
3037         // There should always only be ONE, but with the right combination of
3038         // errors there might be more.  In this case, just return the oldest one (lowest ID).
3039         foreach ($forums as $forum) {
3040             return $forum;   // ie the first one
3041         }
3042     }
3044     // Doesn't exist, so create one now.
3045     $forum = new stdClass();
3046     $forum->course = $courseid;
3047     $forum->type = "$type";
3048     if (!empty($USER->htmleditor)) {
3049         $forum->introformat = $USER->htmleditor;
3050     }
3051     switch ($forum->type) {
3052         case "news":
3053             $forum->name  = get_string("namenews", "forum");
3054             $forum->intro = get_string("intronews", "forum");
3055             $forum->introformat = FORMAT_HTML;
3056             $forum->forcesubscribe = FORUM_FORCESUBSCRIBE;
3057             $forum->assessed = 0;
3058             if ($courseid == SITEID) {
3059                 $forum->name  = get_string("sitenews");
3060                 $forum->forcesubscribe = 0;
3061             }
3062             break;
3063         case "social":
3064             $forum->name  = get_string("namesocial", "forum");
3065             $forum->intro = get_string("introsocial", "forum");
3066             $forum->introformat = FORMAT_HTML;
3067             $forum->assessed = 0;
3068             $forum->forcesubscribe = 0;
3069             break;
3070         case "blog":
3071             $forum->name = get_string('blogforum', 'forum');
3072             $forum->intro = get_string('introblog', 'forum');
3073             $forum->introformat = FORMAT_HTML;
3074             $forum->assessed = 0;
3075             $forum->forcesubscribe = 0;
3076             break;
3077         default:
3078             echo $OUTPUT->notification("That forum type doesn't exist!");
3079             return false;
3080             break;
3081     }
3083     $forum->timemodified = time();
3084     $forum->id = $DB->insert_record("forum", $forum);
3086     if (! $module = $DB->get_record("modules", array("name" => "forum"))) {
3087         echo $OUTPUT->notification("Could not find forum module!!");
3088         return false;
3089     }
3090     $mod = new stdClass();
3091     $mod->course = $courseid;
3092     $mod->module = $module->id;
3093     $mod->instance = $forum->id;
3094     $mod->section = 0;
3095     include_once("$CFG->dirroot/course/lib.php");
3096     if (! $mod->coursemodule = add_course_module($mod) ) {
3097         echo $OUTPUT->notification("Could not add a new course module to the course '" . $courseid . "'");
3098         return false;
3099     }
3100     $sectionid = course_add_cm_to_section($courseid, $mod->coursemodule, 0);
3101     return $DB->get_record("forum", array("id" => "$forum->id"));
3104 /**
3105  * Return a static array of posts that are open.
3106  *
3107  * @return array
3108  */
3109 function forum_post_nesting_cache() {
3110     static $nesting = array();
3111     return $nesting;
3114 /**
3115  * Return true for the first time this post was started
3116  *
3117  * @param int $id The id of the post to start
3118  * @return bool
3119  */
3120 function forum_should_start_post_nesting($id) {
3121     $cache = forum_post_nesting_cache();
3122     if (!array_key_exists($id, $cache)) {
3123         $cache[$id] = 1;
3124         return true;
3125     } else {
3126         $cache[$id]++;
3127         return false;
3128     }
3131 /**
3132  * Return true when all the opens are nested with a close.
3133  *
3134  * @param int $id The id of the post to end
3135  * @return bool
3136  */
3137 function forum_should_end_post_nesting($id) {
3138     $cache = forum_post_nesting_cache();
3139     if (!array_key_exists($id, $cache)) {
3140         return true;
3141     } else {
3142         $cache[$id]--;
3143         if ($cache[$id] == 0) {
3144             unset($cache[$id]);
3145             return true;
3146         }
3147     }
3148     return false;
3151 /**
3152  * Start a forum post container
3153  *
3154  * @param object $post The post to print.
3155  * @param bool $return Return the string or print it
3156  * @return string
3157  */
3158 function forum_print_post_start($post, $return = false) {
3159     $output = '';
3161     if (forum_should_start_post_nesting($post->id)) {
3162         $attributes = [
3163             'id' => 'p'.$post->id,
3164             'tabindex' => -1,
3165             'class' => 'relativelink'
3166         ];
3167         $output .= html_writer::start_tag('article', $attributes);
3168     }
3169     if ($return) {
3170         return $output;
3171     }
3172     echo $output;
3173     return;
3176 /**
3177  * End a forum post container
3178  *
3179  * @param object $post The post to print.
3180  * @param bool $return Return the string or print it
3181  * @return string
3182  */
3183 function forum_print_post_end($post, $return = false) {
3184     $output = '';
3186     if (forum_should_end_post_nesting($post->id)) {
3187         $output .= html_writer::end_tag('article');
3188     }
3189     if ($return) {
3190         return $output;
3191     }
3192     echo $output;
3193     return;
3196 /**
3197  * Print a forum post
3198  * This function should always be surrounded with calls to forum_print_post_start
3199  * and forum_print_post_end to create the surrounding container for the post.
3200  * Replies can be nested before forum_print_post_end and should reflect the structure of
3201  * thread.
3202  *
3203  * @global object
3204  * @global object
3205  * @uses FORUM_MODE_THREADED
3206  * @uses PORTFOLIO_FORMAT_PLAINHTML
3207  * @uses PORTFOLIO_FORMAT_FILE
3208  * @uses PORTFOLIO_FORMAT_RICHHTML
3209  * @uses PORTFOLIO_ADD_TEXT_LINK
3210  * @uses CONTEXT_MODULE
3211  * @param object $post The post to print.
3212  * @param object $discussion
3213  * @param object $forum
3214  * @param object $cm
3215  * @param object $course
3216  * @param boolean $ownpost Whether this post belongs to the current user.
3217  * @param boolean $reply Whether to print a 'reply' link at the bottom of the message.
3218  * @param boolean $link Just print a shortened version of the post as a link to the full post.
3219  * @param string $footer Extra stuff to print after the message.
3220  * @param string $highlight Space-separated list of terms to highlight.
3221  * @param int $post_read true, false or -99. If we already know whether this user
3222  *          has read this post, pass that in, otherwise, pass in -99, and this
3223  *          function will work it out.
3224  * @param boolean $dummyifcantsee When forum_user_can_see_post says that
3225  *          the current user can't see this post, if this argument is true
3226  *          (the default) then print a dummy 'you can't see this post' post.
3227  *          If false, don't output anything at all.
3228  * @param bool|null $istracked
3229  * @return void
3230  */
3231 function forum_print_post($post, $discussion, $forum, &$cm, $course, $ownpost=false, $reply=false, $link=false,
3232                           $footer="", $highlight="", $postisread=null, $dummyifcantsee=true, $istracked=null, $return=false) {
3233     global $USER, $CFG, $OUTPUT;
3235     require_once($CFG->libdir . '/filelib.php');
3237     // String cache
3238     static $str;
3239     // This is an extremely hacky way to ensure we only print the 'unread' anchor
3240     // the first time we encounter an unread post on a page. Ideally this would
3241     // be moved into the caller somehow, and be better testable. But at the time
3242     // of dealing with this bug, this static workaround was the most surgical and
3243     // it fits together with only printing th unread anchor id once on a given page.
3244     static $firstunreadanchorprinted = false;
3246     $modcontext = context_module::instance($cm->id);
3248     $post->course = $course->id;
3249     $post->forum  = $forum->id;
3250     $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
3251     if (!empty($CFG->enableplagiarism)) {
3252         require_once($CFG->libdir.'/plagiarismlib.php');
3253         $post->message .= plagiarism_get_links(array('userid' => $post->userid,
3254             'content' => $post->message,
3255             'cmid' => $cm->id,
3256             'course' => $post->course,
3257             'forum' => $post->forum));
3258     }
3260     // caching
3261     if (!isset($cm->cache)) {
3262         $cm->cache = new stdClass;
3263     }
3265     if (!isset($cm->cache->caps)) {
3266         $cm->cache->caps = array();
3267         $cm->cache->caps['mod/forum:viewdiscussion']   = has_capability('mod/forum:viewdiscussion', $modcontext);
3268         $cm->cache->caps['moodle/site:viewfullnames']  = has_capability('moodle/site:viewfullnames', $modcontext);
3269         $cm->cache->caps['mod/forum:editanypost']      = has_capability('mod/forum:editanypost', $modcontext);
3270         $cm->cache->caps['mod/forum:splitdiscussions'] = has_capability('mod/forum:splitdiscussions', $modcontext);
3271         $cm->cache->caps['mod/forum:deleteownpost']    = has_capability('mod/forum:deleteownpost', $modcontext);
3272         $cm->cache->caps['mod/forum:deleteanypost']    = has_capability('mod/forum:deleteanypost', $modcontext);
3273         $cm->cache->caps['mod/forum:viewanyrating']    = has_capability('mod/forum:viewanyrating', $modcontext);
3274         $cm->cache->caps['mod/forum:exportpost']       = has_capability('mod/forum:exportpost', $modcontext);
3275         $cm->cache->caps['mod/forum:exportownpost']    = has_capability('mod/forum:exportownpost', $modcontext);
3276     }
3278     if (!isset($cm->uservisible)) {
3279         $cm->uservisible = \core_availability\info_module::is_user_visible($cm, 0, false);
3280     }
3282     if ($istracked && is_null($postisread)) {
3283         $postisread = forum_tp_is_post_read($USER->id, $post);
3284     }
3286     if (!forum_user_can_see_post($forum, $discussion, $post, null, $cm, false)) {
3287         // Do _not_ check the deleted flag - we need to display a different UI.
3288         $output = '';
3289         if (!$dummyifcantsee) {
3290             if ($return) {
3291                 return $output;
3292             }
3293             echo $output;
3294             return;
3295         }
3297         $output .= html_writer::start_tag('div', array('class' => 'forumpost clearfix',
3298                                                        'aria-label' => get_string('hiddenforumpost', 'forum')));
3299         $output .= html_writer::start_tag('header', array('class' => 'row header'));
3300         $output .= html_writer::tag('div', '', array('class' => 'left picture', 'role' => 'presentation')); // Picture.
3301         if ($post->parent) {
3302             $output .= html_writer::start_tag('div', array('class' => 'topic'));
3303         } else {
3304             $output .= html_writer::start_tag('div', array('class' => 'topic starter'));
3305         }
3306         $output .= html_writer::tag('div', get_string('forumsubjecthidden','forum'), array('class' => 'subject',
3307                                                                                            'role' => 'header',
3308                                                                                            'id' => ('headp' . $post->id))); // Subject.
3309         $authorclasses = array('class' => 'author');
3310         $output .= html_writer::tag('address', get_string('forumauthorhidden', 'forum'), $authorclasses); // Author.
3311         $output .= html_writer::end_tag('div');
3312         $output .= html_writer::end_tag('header'); // Header.
3313         $output .= html_writer::start_tag('div', array('class'=>'row'));
3314         $output .= html_writer::tag('div', '&nbsp;', array('class'=>'left side')); // Groups
3315         $output .= html_writer::tag('div', get_string('forumbodyhidden','forum'), array('class'=>'content')); // Content
3316         $output .= html_writer::end_tag('div'); // row
3317         $output .= html_writer::end_tag('div'); // forumpost
3319         if ($return) {
3320             return $output;
3321         }
3322         echo $output;
3323         return;
3324     }
3326     if (!empty($post->deleted)) {
3327         // Note: Posts marked as deleted are still returned by the above forum_user_can_post because it is required for
3328         // nesting of posts.
3329         $output = '';
3330         if (!$dummyifcantsee) {
3331             if ($return) {
3332                 return $output;
3333             }
3334             echo $output;
3335             return;
3336         }
3337         $output .= html_writer::start_tag('div', [
3338                 'class' => 'forumpost clearfix',
3339                 'aria-label' => get_string('forumbodydeleted', 'forum'),
3340             ]);
3342         $output .= html_writer::start_tag('header', array('class' => 'row header'));
3343         $output .= html_writer::tag('div', '', array('class' => 'left picture', 'role' => 'presentation'));
3345         $classes = ['topic'];
3346         if (!empty($post->parent)) {
3347             $classes[] = 'starter';
3348         }
3349         $output .= html_writer::start_tag('div', ['class' => implode(' ', $classes)]);
3351         // Subject.
3352         $output .= html_writer::tag('div', get_string('forumsubjectdeleted', 'forum'), [
3353                 'class' => 'subject',
3354                 'role' => 'header',
3355                 'id' => ('headp' . $post->id)
3356             ]);
3358         // Author.
3359         $output .= html_writer::tag('address', '', ['class' => 'author']);
3361         $output .= html_writer::end_tag('div');
3362         $output .= html_writer::end_tag('header'); // End header.
3363         $output .= html_writer::start_tag('div', ['class' => 'row']);
3364         $output .= html_writer::tag('div', '&nbsp;', ['class' => 'left side']); // Groups.
3365         $output .= html_writer::tag('div', get_string('forumbodydeleted', 'forum'), ['class' => 'content']); // Content.
3366         $output .= html_writer::end_tag('div'); // End row.
3367         $output .= html_writer::end_tag('div'); // End forumpost.
3369         if ($return) {
3370             return $output;
3371         }
3372         echo $output;
3373         return;
3374     }
3376     if (empty($str)) {
3377         $str = new stdClass;
3378         $str->edit         = get_string('edit', 'forum');
3379         $str->delete       = get_string('delete', 'forum');
3380         $str->reply        = get_string('reply', 'forum');
3381         $str->parent       = get_string('parent', 'forum');
3382         $str->pruneheading = get_string('pruneheading', 'forum');
3383         $str->prune        = get_string('prune', 'forum');
3384         $str->displaymode     = get_user_preferences('forum_displaymode', $CFG->forum_displaymode);
3385         $str->markread     = get_string('markread', 'forum');
3386         $str->markunread   = get_string('markunread', 'forum');
3387     }
3389     $discussionlink = new moodle_url('/mod/forum/discuss.php', array('d'=>$post->discussion));
3391     // Build an object that represents the posting user
3392     $postuser = new stdClass;
3393     $postuserfields = explode(',', user_picture::fields());
3394     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
3395     $postuser->id = $post->userid;
3396     $postuser->fullname    = fullname($postuser, $cm->cache->caps['moodle/site:viewfullnames']);
3397     $postuser->profilelink = new moodle_url('/user/view.php', array('id'=>$post->userid, 'course'=>$course->id));
3399     // Prepare the groups the posting user belongs to
3400     if (isset($cm->cache->usersgroups)) {
3401         $groups = array();
3402         if (isset($cm->cache->usersgroups[$post->userid])) {
3403             foreach ($cm->cache->usersgroups[$post->userid] as $gid) {
3404                 $groups[$gid] = $cm->cache->groups[$gid];
3405             }
3406         }
3407     } else {
3408         $groups = groups_get_all_groups($course->id, $post->userid, $cm->groupingid);
3409     }
3411     // Prepare the attachements for the post, files then images
3412     list($attachments, $attachedimages) = forum_print_attachments($post, $cm, 'separateimages');
3414     // Determine if we need to shorten this post
3415     $shortenpost = ($link && (strlen(strip_tags($post->message)) > $CFG->forum_longpost));
3417     // Prepare an array of commands
3418     $commands = array();
3420     // Add a permalink.
3421     $permalink = new moodle_url($discussionlink);
3422     $permalink->set_anchor('p' . $post->id);
3423     $commands[] = array('url' => $permalink, 'text' => get_string('permalink', 'forum'), 'attributes' => ['rel' => 'bookmark']);
3425     // SPECIAL CASE: The front page can display a news item post to non-logged in users.
3426     // Don't display the mark read / unread controls in this case.
3427     if ($istracked && $CFG->forum_usermarksread && isloggedin()) {
3428         $url = new moodle_url($discussionlink, array('postid'=>$post->id, 'mark'=>'unread'));
3429         $text = $str->markunread;
3430         if (!$postisread) {
3431             $url->param('mark', 'read');
3432             $text = $str->markread;
3433         }
3434         if ($str->displaymode == FORUM_MODE_THREADED) {
3435             $url->param('parent', $post->parent);
3436         } else {
3437             $url->set_anchor('p'.$post->id);
3438         }
3439         $commands[] = array('url'=>$url, 'text'=>$text, 'attributes' => ['rel' => 'bookmark']);
3440     }
3442     // Zoom in to the parent specifically
3443     if ($post->parent) {
3444         $url = new moodle_url($discussionlink);