MDL-55982 mod_forum: Add time-based discussion locking
[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');
28 require_once($CFG->libdir.'/eventslib.php');
30 /// CONSTANTS ///////////////////////////////////////////////////////////
32 define('FORUM_MODE_FLATOLDEST', 1);
33 define('FORUM_MODE_FLATNEWEST', -1);
34 define('FORUM_MODE_THREADED', 2);
35 define('FORUM_MODE_NESTED', 3);
37 define('FORUM_CHOOSESUBSCRIBE', 0);
38 define('FORUM_FORCESUBSCRIBE', 1);
39 define('FORUM_INITIALSUBSCRIBE', 2);
40 define('FORUM_DISALLOWSUBSCRIBE',3);
42 /**
43  * FORUM_TRACKING_OFF - Tracking is not available for this forum.
44  */
45 define('FORUM_TRACKING_OFF', 0);
47 /**
48  * FORUM_TRACKING_OPTIONAL - Tracking is based on user preference.
49  */
50 define('FORUM_TRACKING_OPTIONAL', 1);
52 /**
53  * FORUM_TRACKING_FORCED - Tracking is on, regardless of user setting.
54  * Treated as FORUM_TRACKING_OPTIONAL if $CFG->forum_allowforcedreadtracking is off.
55  */
56 define('FORUM_TRACKING_FORCED', 2);
58 define('FORUM_MAILED_PENDING', 0);
59 define('FORUM_MAILED_SUCCESS', 1);
60 define('FORUM_MAILED_ERROR', 2);
62 if (!defined('FORUM_CRON_USER_CACHE')) {
63     /** Defines how many full user records are cached in forum cron. */
64     define('FORUM_CRON_USER_CACHE', 5000);
65 }
67 /**
68  * FORUM_POSTS_ALL_USER_GROUPS - All the posts in groups where the user is enrolled.
69  */
70 define('FORUM_POSTS_ALL_USER_GROUPS', -2);
72 define('FORUM_DISCUSSION_PINNED', 1);
73 define('FORUM_DISCUSSION_UNPINNED', 0);
75 /// STANDARD FUNCTIONS ///////////////////////////////////////////////////////////
77 /**
78  * Given an object containing all the necessary data,
79  * (defined by the form in mod_form.php) this function
80  * will create a new instance and return the id number
81  * of the new instance.
82  *
83  * @param stdClass $forum add forum instance
84  * @param mod_forum_mod_form $mform
85  * @return int intance id
86  */
87 function forum_add_instance($forum, $mform = null) {
88     global $CFG, $DB;
90     $forum->timemodified = time();
92     if (empty($forum->assessed)) {
93         $forum->assessed = 0;
94     }
96     if (empty($forum->ratingtime) or empty($forum->assessed)) {
97         $forum->assesstimestart  = 0;
98         $forum->assesstimefinish = 0;
99     }
101     $forum->id = $DB->insert_record('forum', $forum);
102     $modcontext = context_module::instance($forum->coursemodule);
104     if ($forum->type == 'single') {  // Create related discussion.
105         $discussion = new stdClass();
106         $discussion->course        = $forum->course;
107         $discussion->forum         = $forum->id;
108         $discussion->name          = $forum->name;
109         $discussion->assessed      = $forum->assessed;
110         $discussion->message       = $forum->intro;
111         $discussion->messageformat = $forum->introformat;
112         $discussion->messagetrust  = trusttext_trusted(context_course::instance($forum->course));
113         $discussion->mailnow       = false;
114         $discussion->groupid       = -1;
116         $message = '';
118         $discussion->id = forum_add_discussion($discussion, null, $message);
120         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
121             // Ugly hack - we need to copy the files somehow.
122             $discussion = $DB->get_record('forum_discussions', array('id'=>$discussion->id), '*', MUST_EXIST);
123             $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
125             $options = array('subdirs'=>true); // Use the same options as intro field!
126             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
127             $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
128         }
129     }
131     forum_grade_item_update($forum);
133     return $forum->id;
136 /**
137  * Handle changes following the creation of a forum instance.
138  * This function is typically called by the course_module_created observer.
139  *
140  * @param object $context the forum context
141  * @param stdClass $forum The forum object
142  * @return void
143  */
144 function forum_instance_created($context, $forum) {
145     if ($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) {
146         $users = \mod_forum\subscriptions::get_potential_subscribers($context, 0, 'u.id, u.email');
147         foreach ($users as $user) {
148             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $context);
149         }
150     }
153 /**
154  * Given an object containing all the necessary data,
155  * (defined by the form in mod_form.php) this function
156  * will update an existing instance with new data.
157  *
158  * @global object
159  * @param object $forum forum instance (with magic quotes)
160  * @return bool success
161  */
162 function forum_update_instance($forum, $mform) {
163     global $DB, $OUTPUT, $USER;
165     $forum->timemodified = time();
166     $forum->id           = $forum->instance;
168     if (empty($forum->assessed)) {
169         $forum->assessed = 0;
170     }
172     if (empty($forum->ratingtime) or empty($forum->assessed)) {
173         $forum->assesstimestart  = 0;
174         $forum->assesstimefinish = 0;
175     }
177     $oldforum = $DB->get_record('forum', array('id'=>$forum->id));
179     // MDL-3942 - if the aggregation type or scale (i.e. max grade) changes then recalculate the grades for the entire forum
180     // if  scale changes - do we need to recheck the ratings, if ratings higher than scale how do we want to respond?
181     // 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
182     if (($oldforum->assessed<>$forum->assessed) or ($oldforum->scale<>$forum->scale)) {
183         forum_update_grades($forum); // recalculate grades for the forum
184     }
186     if ($forum->type == 'single') {  // Update related discussion and post.
187         $discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id), 'timemodified ASC');
188         if (!empty($discussions)) {
189             if (count($discussions) > 1) {
190                 echo $OUTPUT->notification(get_string('warnformorepost', 'forum'));
191             }
192             $discussion = array_pop($discussions);
193         } else {
194             // try to recover by creating initial discussion - MDL-16262
195             $discussion = new stdClass();
196             $discussion->course          = $forum->course;
197             $discussion->forum           = $forum->id;
198             $discussion->name            = $forum->name;
199             $discussion->assessed        = $forum->assessed;
200             $discussion->message         = $forum->intro;
201             $discussion->messageformat   = $forum->introformat;
202             $discussion->messagetrust    = true;
203             $discussion->mailnow         = false;
204             $discussion->groupid         = -1;
206             $message = '';
208             forum_add_discussion($discussion, null, $message);
210             if (! $discussion = $DB->get_record('forum_discussions', array('forum'=>$forum->id))) {
211                 print_error('cannotadd', 'forum');
212             }
213         }
214         if (! $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost))) {
215             print_error('cannotfindfirstpost', 'forum');
216         }
218         $cm         = get_coursemodule_from_instance('forum', $forum->id);
219         $modcontext = context_module::instance($cm->id, MUST_EXIST);
221         $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
222         $post->subject       = $forum->name;
223         $post->message       = $forum->intro;
224         $post->messageformat = $forum->introformat;
225         $post->messagetrust  = trusttext_trusted($modcontext);
226         $post->modified      = $forum->timemodified;
227         $post->userid        = $USER->id;    // MDL-18599, so that current teacher can take ownership of activities.
229         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
230             // Ugly hack - we need to copy the files somehow.
231             $options = array('subdirs'=>true); // Use the same options as intro field!
232             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
233         }
235         $DB->update_record('forum_posts', $post);
236         $discussion->name = $forum->name;
237         $DB->update_record('forum_discussions', $discussion);
238     }
240     $DB->update_record('forum', $forum);
242     $modcontext = context_module::instance($forum->coursemodule);
243     if (($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) && ($oldforum->forcesubscribe <> $forum->forcesubscribe)) {
244         $users = \mod_forum\subscriptions::get_potential_subscribers($modcontext, 0, 'u.id, u.email', '');
245         foreach ($users as $user) {
246             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $modcontext);
247         }
248     }
250     forum_grade_item_update($forum);
252     return true;
256 /**
257  * Given an ID of an instance of this module,
258  * this function will permanently delete the instance
259  * and any data that depends on it.
260  *
261  * @global object
262  * @param int $id forum instance id
263  * @return bool success
264  */
265 function forum_delete_instance($id) {
266     global $DB;
268     if (!$forum = $DB->get_record('forum', array('id'=>$id))) {
269         return false;
270     }
271     if (!$cm = get_coursemodule_from_instance('forum', $forum->id)) {
272         return false;
273     }
274     if (!$course = $DB->get_record('course', array('id'=>$cm->course))) {
275         return false;
276     }
278     $context = context_module::instance($cm->id);
280     // now get rid of all files
281     $fs = get_file_storage();
282     $fs->delete_area_files($context->id);
284     $result = true;
286     // Delete digest and subscription preferences.
287     $DB->delete_records('forum_digests', array('forum' => $forum->id));
288     $DB->delete_records('forum_subscriptions', array('forum'=>$forum->id));
289     $DB->delete_records('forum_discussion_subs', array('forum' => $forum->id));
291     if ($discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id))) {
292         foreach ($discussions as $discussion) {
293             if (!forum_delete_discussion($discussion, true, $course, $cm, $forum)) {
294                 $result = false;
295             }
296         }
297     }
299     forum_tp_delete_read_records(-1, -1, -1, $forum->id);
301     if (!$DB->delete_records('forum', array('id'=>$forum->id))) {
302         $result = false;
303     }
305     forum_grade_item_delete($forum);
307     return $result;
311 /**
312  * Indicates API features that the forum supports.
313  *
314  * @uses FEATURE_GROUPS
315  * @uses FEATURE_GROUPINGS
316  * @uses FEATURE_MOD_INTRO
317  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
318  * @uses FEATURE_COMPLETION_HAS_RULES
319  * @uses FEATURE_GRADE_HAS_GRADE
320  * @uses FEATURE_GRADE_OUTCOMES
321  * @param string $feature
322  * @return mixed True if yes (some features may use other values)
323  */
324 function forum_supports($feature) {
325     switch($feature) {
326         case FEATURE_GROUPS:                  return true;
327         case FEATURE_GROUPINGS:               return true;
328         case FEATURE_MOD_INTRO:               return true;
329         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
330         case FEATURE_COMPLETION_HAS_RULES:    return true;
331         case FEATURE_GRADE_HAS_GRADE:         return true;
332         case FEATURE_GRADE_OUTCOMES:          return true;
333         case FEATURE_RATE:                    return true;
334         case FEATURE_BACKUP_MOODLE2:          return true;
335         case FEATURE_SHOW_DESCRIPTION:        return true;
336         case FEATURE_PLAGIARISM:              return true;
338         default: return null;
339     }
343 /**
344  * Obtains the automatic completion state for this forum based on any conditions
345  * in forum settings.
346  *
347  * @global object
348  * @global object
349  * @param object $course Course
350  * @param object $cm Course-module
351  * @param int $userid User ID
352  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
353  * @return bool True if completed, false if not. (If no conditions, then return
354  *   value depends on comparison type)
355  */
356 function forum_get_completion_state($course,$cm,$userid,$type) {
357     global $CFG,$DB;
359     // Get forum details
360     if (!($forum=$DB->get_record('forum',array('id'=>$cm->instance)))) {
361         throw new Exception("Can't find forum {$cm->instance}");
362     }
364     $result=$type; // Default return value
366     $postcountparams=array('userid'=>$userid,'forumid'=>$forum->id);
367     $postcountsql="
368 SELECT
369     COUNT(1)
370 FROM
371     {forum_posts} fp
372     INNER JOIN {forum_discussions} fd ON fp.discussion=fd.id
373 WHERE
374     fp.userid=:userid AND fd.forum=:forumid";
376     if ($forum->completiondiscussions) {
377         $value = $forum->completiondiscussions <=
378                  $DB->count_records('forum_discussions',array('forum'=>$forum->id,'userid'=>$userid));
379         if ($type == COMPLETION_AND) {
380             $result = $result && $value;
381         } else {
382             $result = $result || $value;
383         }
384     }
385     if ($forum->completionreplies) {
386         $value = $forum->completionreplies <=
387                  $DB->get_field_sql( $postcountsql.' AND fp.parent<>0',$postcountparams);
388         if ($type==COMPLETION_AND) {
389             $result = $result && $value;
390         } else {
391             $result = $result || $value;
392         }
393     }
394     if ($forum->completionposts) {
395         $value = $forum->completionposts <= $DB->get_field_sql($postcountsql,$postcountparams);
396         if ($type == COMPLETION_AND) {
397             $result = $result && $value;
398         } else {
399             $result = $result || $value;
400         }
401     }
403     return $result;
406 /**
407  * Create a message-id string to use in the custom headers of forum notification emails
408  *
409  * message-id is used by email clients to identify emails and to nest conversations
410  *
411  * @param int $postid The ID of the forum post we are notifying the user about
412  * @param int $usertoid The ID of the user being notified
413  * @return string A unique message-id
414  */
415 function forum_get_email_message_id($postid, $usertoid) {
416     return generate_email_messageid(hash('sha256', $postid . 'to' . $usertoid));
419 /**
420  * Removes properties from user record that are not necessary
421  * for sending post notifications.
422  * @param stdClass $user
423  * @return void, $user parameter is modified
424  */
425 function forum_cron_minimise_user_record(stdClass $user) {
427     // We store large amount of users in one huge array,
428     // make sure we do not store info there we do not actually need
429     // in mail generation code or messaging.
431     unset($user->institution);
432     unset($user->department);
433     unset($user->address);
434     unset($user->city);
435     unset($user->url);
436     unset($user->currentlogin);
437     unset($user->description);
438     unset($user->descriptionformat);
441 /**
442  * Function to be run periodically according to the scheduled task.
443  *
444  * Finds all posts that have yet to be mailed out, and mails them
445  * out to all subscribers as well as other maintance tasks.
446  *
447  * NOTE: Since 2.7.2 this function is run by scheduled task rather
448  * than standard cron.
449  *
450  * @todo MDL-44734 The function will be split up into seperate tasks.
451  */
452 function forum_cron() {
453     global $CFG, $USER, $DB, $PAGE;
455     $site = get_site();
457     // The main renderers.
458     $htmlout = $PAGE->get_renderer('mod_forum', 'email', 'htmlemail');
459     $textout = $PAGE->get_renderer('mod_forum', 'email', 'textemail');
460     $htmldigestfullout = $PAGE->get_renderer('mod_forum', 'emaildigestfull', 'htmlemail');
461     $textdigestfullout = $PAGE->get_renderer('mod_forum', 'emaildigestfull', 'textemail');
462     $htmldigestbasicout = $PAGE->get_renderer('mod_forum', 'emaildigestbasic', 'htmlemail');
463     $textdigestbasicout = $PAGE->get_renderer('mod_forum', 'emaildigestbasic', 'textemail');
465     // All users that are subscribed to any post that needs sending,
466     // please increase $CFG->extramemorylimit on large sites that
467     // send notifications to a large number of users.
468     $users = array();
469     $userscount = 0; // Cached user counter - count($users) in PHP is horribly slow!!!
471     // Status arrays.
472     $mailcount  = array();
473     $errorcount = array();
475     // caches
476     $discussions        = array();
477     $forums             = array();
478     $courses            = array();
479     $coursemodules      = array();
480     $subscribedusers    = array();
481     $messageinboundhandlers = array();
483     // Posts older than 2 days will not be mailed.  This is to avoid the problem where
484     // cron has not been running for a long time, and then suddenly people are flooded
485     // with mail from the past few weeks or months
486     $timenow   = time();
487     $endtime   = $timenow - $CFG->maxeditingtime;
488     $starttime = $endtime - 48 * 3600;   // Two days earlier
490     // Get the list of forum subscriptions for per-user per-forum maildigest settings.
491     $digestsset = $DB->get_recordset('forum_digests', null, '', 'id, userid, forum, maildigest');
492     $digests = array();
493     foreach ($digestsset as $thisrow) {
494         if (!isset($digests[$thisrow->forum])) {
495             $digests[$thisrow->forum] = array();
496         }
497         $digests[$thisrow->forum][$thisrow->userid] = $thisrow->maildigest;
498     }
499     $digestsset->close();
501     // Create the generic messageinboundgenerator.
502     $messageinboundgenerator = new \core\message\inbound\address_manager();
503     $messageinboundgenerator->set_handler('\mod_forum\message\inbound\reply_handler');
505     if ($posts = forum_get_unmailed_posts($starttime, $endtime, $timenow)) {
506         // Mark them all now as being mailed.  It's unlikely but possible there
507         // might be an error later so that a post is NOT actually mailed out,
508         // but since mail isn't crucial, we can accept this risk.  Doing it now
509         // prevents the risk of duplicated mails, which is a worse problem.
511         if (!forum_mark_old_posts_as_mailed($endtime)) {
512             mtrace('Errors occurred while trying to mark some posts as being mailed.');
513             return false;  // Don't continue trying to mail them, in case we are in a cron loop
514         }
516         // checking post validity, and adding users to loop through later
517         foreach ($posts as $pid => $post) {
519             $discussionid = $post->discussion;
520             if (!isset($discussions[$discussionid])) {
521                 if ($discussion = $DB->get_record('forum_discussions', array('id'=> $post->discussion))) {
522                     $discussions[$discussionid] = $discussion;
523                     \mod_forum\subscriptions::fill_subscription_cache($discussion->forum);
524                     \mod_forum\subscriptions::fill_discussion_subscription_cache($discussion->forum);
526                 } else {
527                     mtrace('Could not find discussion ' . $discussionid);
528                     unset($posts[$pid]);
529                     continue;
530                 }
531             }
532             $forumid = $discussions[$discussionid]->forum;
533             if (!isset($forums[$forumid])) {
534                 if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
535                     $forums[$forumid] = $forum;
536                 } else {
537                     mtrace('Could not find forum '.$forumid);
538                     unset($posts[$pid]);
539                     continue;
540                 }
541             }
542             $courseid = $forums[$forumid]->course;
543             if (!isset($courses[$courseid])) {
544                 if ($course = $DB->get_record('course', array('id' => $courseid))) {
545                     $courses[$courseid] = $course;
546                 } else {
547                     mtrace('Could not find course '.$courseid);
548                     unset($posts[$pid]);
549                     continue;
550                 }
551             }
552             if (!isset($coursemodules[$forumid])) {
553                 if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
554                     $coursemodules[$forumid] = $cm;
555                 } else {
556                     mtrace('Could not find course module for forum '.$forumid);
557                     unset($posts[$pid]);
558                     continue;
559                 }
560             }
562             // Save the Inbound Message datakey here to reduce DB queries later.
563             $messageinboundgenerator->set_data($pid);
564             $messageinboundhandlers[$pid] = $messageinboundgenerator->fetch_data_key();
566             // Caching subscribed users of each forum.
567             if (!isset($subscribedusers[$forumid])) {
568                 $modcontext = context_module::instance($coursemodules[$forumid]->id);
569                 if ($subusers = \mod_forum\subscriptions::fetch_subscribed_users($forums[$forumid], 0, $modcontext, 'u.*', true)) {
571                     foreach ($subusers as $postuser) {
572                         // this user is subscribed to this forum
573                         $subscribedusers[$forumid][$postuser->id] = $postuser->id;
574                         $userscount++;
575                         if ($userscount > FORUM_CRON_USER_CACHE) {
576                             // Store minimal user info.
577                             $minuser = new stdClass();
578                             $minuser->id = $postuser->id;
579                             $users[$postuser->id] = $minuser;
580                         } else {
581                             // Cache full user record.
582                             forum_cron_minimise_user_record($postuser);
583                             $users[$postuser->id] = $postuser;
584                         }
585                     }
586                     // Release memory.
587                     unset($subusers);
588                     unset($postuser);
589                 }
590             }
591             $mailcount[$pid] = 0;
592             $errorcount[$pid] = 0;
593         }
594     }
596     if ($users && $posts) {
598         foreach ($users as $userto) {
599             // Terminate if processing of any account takes longer than 2 minutes.
600             core_php_time_limit::raise(120);
602             mtrace('Processing user ' . $userto->id);
604             // Init user caches - we keep the cache for one cycle only, otherwise it could consume too much memory.
605             if (isset($userto->username)) {
606                 $userto = clone($userto);
607             } else {
608                 $userto = $DB->get_record('user', array('id' => $userto->id));
609                 forum_cron_minimise_user_record($userto);
610             }
611             $userto->viewfullnames = array();
612             $userto->canpost       = array();
613             $userto->markposts     = array();
615             // Setup this user so that the capabilities are cached, and environment matches receiving user.
616             cron_setup_user($userto);
618             // Reset the caches.
619             foreach ($coursemodules as $forumid => $unused) {
620                 $coursemodules[$forumid]->cache       = new stdClass();
621                 $coursemodules[$forumid]->cache->caps = array();
622                 unset($coursemodules[$forumid]->uservisible);
623             }
625             foreach ($posts as $pid => $post) {
626                 $discussion = $discussions[$post->discussion];
627                 $forum      = $forums[$discussion->forum];
628                 $course     = $courses[$forum->course];
629                 $cm         =& $coursemodules[$forum->id];
631                 // Do some checks to see if we can bail out now.
633                 // Only active enrolled users are in the list of subscribers.
634                 // This does not necessarily mean that the user is subscribed to the forum or to the discussion though.
635                 if (!isset($subscribedusers[$forum->id][$userto->id])) {
636                     // The user does not subscribe to this forum.
637                     continue;
638                 }
640                 if (!\mod_forum\subscriptions::is_subscribed($userto->id, $forum, $post->discussion, $coursemodules[$forum->id])) {
641                     // The user does not subscribe to this forum, or to this specific discussion.
642                     continue;
643                 }
645                 if ($subscriptiontime = \mod_forum\subscriptions::fetch_discussion_subscription($forum->id, $userto->id)) {
646                     // Skip posts if the user subscribed to the discussion after it was created.
647                     if (isset($subscriptiontime[$post->discussion]) && ($subscriptiontime[$post->discussion] > $post->created)) {
648                         continue;
649                     }
650                 }
652                 // Don't send email if the forum is Q&A and the user has not posted.
653                 // Initial topics are still mailed.
654                 if ($forum->type == 'qanda' && !forum_get_user_posted_time($discussion->id, $userto->id) && $pid != $discussion->firstpost) {
655                     mtrace('Did not email ' . $userto->id.' because user has not posted in discussion');
656                     continue;
657                 }
659                 // Get info about the sending user.
660                 if (array_key_exists($post->userid, $users)) {
661                     // We might know the user already.
662                     $userfrom = $users[$post->userid];
663                     if (!isset($userfrom->idnumber)) {
664                         // Minimalised user info, fetch full record.
665                         $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
666                         forum_cron_minimise_user_record($userfrom);
667                     }
669                 } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
670                     forum_cron_minimise_user_record($userfrom);
671                     // Fetch only once if possible, we can add it to user list, it will be skipped anyway.
672                     if ($userscount <= FORUM_CRON_USER_CACHE) {
673                         $userscount++;
674                         $users[$userfrom->id] = $userfrom;
675                     }
676                 } else {
677                     mtrace('Could not find user ' . $post->userid . ', author of post ' . $post->id . '. Unable to send message.');
678                     continue;
679                 }
681                 // Note: If we want to check that userto and userfrom are not the same person this is probably the spot to do it.
683                 // Setup global $COURSE properly - needed for roles and languages.
684                 cron_setup_user($userto, $course);
686                 // Fill caches.
687                 if (!isset($userto->viewfullnames[$forum->id])) {
688                     $modcontext = context_module::instance($cm->id);
689                     $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
690                 }
691                 if (!isset($userto->canpost[$discussion->id])) {
692                     $modcontext = context_module::instance($cm->id);
693                     $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
694                 }
695                 if (!isset($userfrom->groups[$forum->id])) {
696                     if (!isset($userfrom->groups)) {
697                         $userfrom->groups = array();
698                         if (isset($users[$userfrom->id])) {
699                             $users[$userfrom->id]->groups = array();
700                         }
701                     }
702                     $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
703                     if (isset($users[$userfrom->id])) {
704                         $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
705                     }
706                 }
708                 // Make sure groups allow this user to see this email.
709                 if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {
710                     // Groups are being used.
711                     if (!groups_group_exists($discussion->groupid)) {
712                         // Can't find group - be safe and don't this message.
713                         continue;
714                     }
716                     if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $modcontext)) {
717                         // Do not send posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS.
718                         continue;
719                     }
720                 }
722                 // Make sure we're allowed to see the post.
723                 if (!forum_user_can_see_post($forum, $discussion, $post, null, $cm)) {
724                     mtrace('User ' . $userto->id .' can not see ' . $post->id . '. Not sending message.');
725                     continue;
726                 }
728                 // OK so we need to send the email.
730                 // Does the user want this post in a digest?  If so postpone it for now.
731                 $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
733                 if ($maildigest > 0) {
734                     // This user wants the mails to be in digest form.
735                     $queue = new stdClass();
736                     $queue->userid       = $userto->id;
737                     $queue->discussionid = $discussion->id;
738                     $queue->postid       = $post->id;
739                     $queue->timemodified = $post->created;
740                     $DB->insert_record('forum_queue', $queue);
741                     continue;
742                 }
744                 // Prepare to actually send the post now, and build up the content.
746                 $cleanforumname = str_replace('"', "'", strip_tags(format_string($forum->name)));
748                 $userfrom->customheaders = array (
749                     // Headers to make emails easier to track.
750                     'List-Id: "'        . $cleanforumname . '" ' . generate_email_messageid('moodleforum' . $forum->id),
751                     'List-Help: '       . $CFG->wwwroot . '/mod/forum/view.php?f=' . $forum->id,
752                     'Message-ID: '      . forum_get_email_message_id($post->id, $userto->id),
753                     'X-Course-Id: '     . $course->id,
754                     'X-Course-Name: '   . format_string($course->fullname, true),
756                     // Headers to help prevent auto-responders.
757                     'Precedence: Bulk',
758                     'X-Auto-Response-Suppress: All',
759                     'Auto-Submitted: auto-generated',
760                 );
762                 $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
764                 // Generate a reply-to address from using the Inbound Message handler.
765                 $replyaddress = null;
766                 if ($userto->canpost[$discussion->id] && array_key_exists($post->id, $messageinboundhandlers)) {
767                     $messageinboundgenerator->set_data($post->id, $messageinboundhandlers[$post->id]);
768                     $replyaddress = $messageinboundgenerator->generate($userto->id);
769                 }
771                 if (!isset($userto->canpost[$discussion->id])) {
772                     $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
773                 } else {
774                     $canreply = $userto->canpost[$discussion->id];
775                 }
777                 $data = new \mod_forum\output\forum_post_email(
778                         $course,
779                         $cm,
780                         $forum,
781                         $discussion,
782                         $post,
783                         $userfrom,
784                         $userto,
785                         $canreply
786                     );
788                 $userfrom->customheaders[] = sprintf('List-Unsubscribe: <%s>',
789                     $data->get_unsubscribediscussionlink());
791                 if (!isset($userto->viewfullnames[$forum->id])) {
792                     $data->viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
793                 } else {
794                     $data->viewfullnames = $userto->viewfullnames[$forum->id];
795                 }
797                 // Not all of these variables are used in the default language
798                 // string but are made available to support custom subjects.
799                 $a = new stdClass();
800                 $a->subject = $data->get_subject();
801                 $a->forumname = $cleanforumname;
802                 $a->sitefullname = format_string($site->fullname);
803                 $a->siteshortname = format_string($site->shortname);
804                 $a->courseidnumber = $data->get_courseidnumber();
805                 $a->coursefullname = $data->get_coursefullname();
806                 $a->courseshortname = $data->get_coursename();
807                 $postsubject = html_to_text(get_string('postmailsubject', 'forum', $a), 0);
809                 $rootid = forum_get_email_message_id($discussion->firstpost, $userto->id);
811                 if ($post->parent) {
812                     // This post is a reply, so add reply header (RFC 2822).
813                     $parentid = forum_get_email_message_id($post->parent, $userto->id);
814                     $userfrom->customheaders[] = "In-Reply-To: $parentid";
816                     // If the post is deeply nested we also reference the parent message id and
817                     // the root message id (if different) to aid threading when parts of the email
818                     // conversation have been deleted (RFC1036).
819                     if ($post->parent != $discussion->firstpost) {
820                         $userfrom->customheaders[] = "References: $rootid $parentid";
821                     } else {
822                         $userfrom->customheaders[] = "References: $parentid";
823                     }
824                 }
826                 // MS Outlook / Office uses poorly documented and non standard headers, including
827                 // Thread-Topic which overrides the Subject and shouldn't contain Re: or Fwd: etc.
828                 $a->subject = $discussion->name;
829                 $threadtopic = html_to_text(get_string('postmailsubject', 'forum', $a), 0);
830                 $userfrom->customheaders[] = "Thread-Topic: $threadtopic";
831                 $userfrom->customheaders[] = "Thread-Index: " . substr($rootid, 1, 28);
833                 // Send the post now!
834                 mtrace('Sending ', '');
836                 $eventdata = new \core\message\message();
837                 $eventdata->component           = 'mod_forum';
838                 $eventdata->name                = 'posts';
839                 $eventdata->userfrom            = $userfrom;
840                 $eventdata->userto              = $userto;
841                 $eventdata->subject             = $postsubject;
842                 $eventdata->fullmessage         = $textout->render($data);
843                 $eventdata->fullmessageformat   = FORMAT_PLAIN;
844                 $eventdata->fullmessagehtml     = $htmlout->render($data);
845                 $eventdata->notification        = 1;
846                 $eventdata->replyto             = $replyaddress;
847                 if (!empty($replyaddress)) {
848                     // Add extra text to email messages if they can reply back.
849                     $textfooter = "\n\n" . get_string('replytopostbyemail', 'mod_forum');
850                     $htmlfooter = html_writer::tag('p', get_string('replytopostbyemail', 'mod_forum'));
851                     $additionalcontent = array('fullmessage' => array('footer' => $textfooter),
852                                      'fullmessagehtml' => array('footer' => $htmlfooter));
853                     $eventdata->set_additional_content('email', $additionalcontent);
854                 }
856                 // If forum_replytouser is not set then send mail using the noreplyaddress.
857                 if (empty($CFG->forum_replytouser)) {
858                     $eventdata->userfrom = core_user::get_noreply_user();
859                 }
861                 $smallmessagestrings = new stdClass();
862                 $smallmessagestrings->user          = fullname($userfrom);
863                 $smallmessagestrings->forumname     = "$shortname: " . format_string($forum->name, true) . ": " . $discussion->name;
864                 $smallmessagestrings->message       = $post->message;
866                 // Make sure strings are in message recipients language.
867                 $eventdata->smallmessage = get_string_manager()->get_string('smallmessage', 'forum', $smallmessagestrings, $userto->lang);
869                 $contexturl = new moodle_url('/mod/forum/discuss.php', array('d' => $discussion->id), 'p' . $post->id);
870                 $eventdata->contexturl = $contexturl->out();
871                 $eventdata->contexturlname = $discussion->name;
873                 $mailresult = message_send($eventdata);
874                 if (!$mailresult) {
875                     mtrace("Error: mod/forum/lib.php forum_cron(): Could not send out mail for id $post->id to user $userto->id".
876                             " ($userto->email) .. not trying again.");
877                     $errorcount[$post->id]++;
878                 } else {
879                     $mailcount[$post->id]++;
881                     // Mark post as read if forum_usermarksread is set off.
882                     if (!$CFG->forum_usermarksread) {
883                         $userto->markposts[$post->id] = $post->id;
884                     }
885                 }
887                 mtrace('post ' . $post->id . ': ' . $post->subject);
888             }
890             // Mark processed posts as read.
891             forum_tp_mark_posts_read($userto, $userto->markposts);
892             unset($userto);
893         }
894     }
896     if ($posts) {
897         foreach ($posts as $post) {
898             mtrace($mailcount[$post->id]." users were sent post $post->id, '$post->subject'");
899             if ($errorcount[$post->id]) {
900                 $DB->set_field('forum_posts', 'mailed', FORUM_MAILED_ERROR, array('id' => $post->id));
901             }
902         }
903     }
905     // release some memory
906     unset($subscribedusers);
907     unset($mailcount);
908     unset($errorcount);
910     cron_setup_user();
912     $sitetimezone = core_date::get_server_timezone();
914     // Now see if there are any digest mails waiting to be sent, and if we should send them
916     mtrace('Starting digest processing...');
918     core_php_time_limit::raise(300); // terminate if not able to fetch all digests in 5 minutes
920     if (!isset($CFG->digestmailtimelast)) {    // To catch the first time
921         set_config('digestmailtimelast', 0);
922     }
924     $timenow = time();
925     $digesttime = usergetmidnight($timenow, $sitetimezone) + ($CFG->digestmailtime * 3600);
927     // Delete any really old ones (normally there shouldn't be any)
928     $weekago = $timenow - (7 * 24 * 3600);
929     $DB->delete_records_select('forum_queue', "timemodified < ?", array($weekago));
930     mtrace ('Cleaned old digest records');
932     if ($CFG->digestmailtimelast < $digesttime and $timenow > $digesttime) {
934         mtrace('Sending forum digests: '.userdate($timenow, '', $sitetimezone));
936         $digestposts_rs = $DB->get_recordset_select('forum_queue', "timemodified < ?", array($digesttime));
938         if ($digestposts_rs->valid()) {
940             // We have work to do
941             $usermailcount = 0;
943             //caches - reuse the those filled before too
944             $discussionposts = array();
945             $userdiscussions = array();
947             foreach ($digestposts_rs as $digestpost) {
948                 if (!isset($posts[$digestpost->postid])) {
949                     if ($post = $DB->get_record('forum_posts', array('id' => $digestpost->postid))) {
950                         $posts[$digestpost->postid] = $post;
951                     } else {
952                         continue;
953                     }
954                 }
955                 $discussionid = $digestpost->discussionid;
956                 if (!isset($discussions[$discussionid])) {
957                     if ($discussion = $DB->get_record('forum_discussions', array('id' => $discussionid))) {
958                         $discussions[$discussionid] = $discussion;
959                     } else {
960                         continue;
961                     }
962                 }
963                 $forumid = $discussions[$discussionid]->forum;
964                 if (!isset($forums[$forumid])) {
965                     if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
966                         $forums[$forumid] = $forum;
967                     } else {
968                         continue;
969                     }
970                 }
972                 $courseid = $forums[$forumid]->course;
973                 if (!isset($courses[$courseid])) {
974                     if ($course = $DB->get_record('course', array('id' => $courseid))) {
975                         $courses[$courseid] = $course;
976                     } else {
977                         continue;
978                     }
979                 }
981                 if (!isset($coursemodules[$forumid])) {
982                     if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
983                         $coursemodules[$forumid] = $cm;
984                     } else {
985                         continue;
986                     }
987                 }
988                 $userdiscussions[$digestpost->userid][$digestpost->discussionid] = $digestpost->discussionid;
989                 $discussionposts[$digestpost->discussionid][$digestpost->postid] = $digestpost->postid;
990             }
991             $digestposts_rs->close(); /// Finished iteration, let's close the resultset
993             // Data collected, start sending out emails to each user
994             foreach ($userdiscussions as $userid => $thesediscussions) {
996                 core_php_time_limit::raise(120); // terminate if processing of any account takes longer than 2 minutes
998                 cron_setup_user();
1000                 mtrace(get_string('processingdigest', 'forum', $userid), '... ');
1002                 // First of all delete all the queue entries for this user
1003                 $DB->delete_records_select('forum_queue', "userid = ? AND timemodified < ?", array($userid, $digesttime));
1005                 // Init user caches - we keep the cache for one cycle only,
1006                 // otherwise it would unnecessarily consume memory.
1007                 if (array_key_exists($userid, $users) and isset($users[$userid]->username)) {
1008                     $userto = clone($users[$userid]);
1009                 } else {
1010                     $userto = $DB->get_record('user', array('id' => $userid));
1011                     forum_cron_minimise_user_record($userto);
1012                 }
1013                 $userto->viewfullnames = array();
1014                 $userto->canpost       = array();
1015                 $userto->markposts     = array();
1017                 // Override the language and timezone of the "current" user, so that
1018                 // mail is customised for the receiver.
1019                 cron_setup_user($userto);
1021                 $postsubject = get_string('digestmailsubject', 'forum', format_string($site->shortname, true));
1023                 $headerdata = new stdClass();
1024                 $headerdata->sitename = format_string($site->fullname, true);
1025                 $headerdata->userprefs = $CFG->wwwroot.'/user/forum.php?id='.$userid.'&amp;course='.$site->id;
1027                 $posttext = get_string('digestmailheader', 'forum', $headerdata)."\n\n";
1028                 $headerdata->userprefs = '<a target="_blank" href="'.$headerdata->userprefs.'">'.get_string('digestmailprefs', 'forum').'</a>';
1030                 $posthtml = '<p>'.get_string('digestmailheader', 'forum', $headerdata).'</p>'
1031                     . '<br /><hr size="1" noshade="noshade" />';
1033                 foreach ($thesediscussions as $discussionid) {
1035                     core_php_time_limit::raise(120);   // to be reset for each post
1037                     $discussion = $discussions[$discussionid];
1038                     $forum      = $forums[$discussion->forum];
1039                     $course     = $courses[$forum->course];
1040                     $cm         = $coursemodules[$forum->id];
1042                     //override language
1043                     cron_setup_user($userto, $course);
1045                     // Fill caches
1046                     if (!isset($userto->viewfullnames[$forum->id])) {
1047                         $modcontext = context_module::instance($cm->id);
1048                         $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
1049                     }
1050                     if (!isset($userto->canpost[$discussion->id])) {
1051                         $modcontext = context_module::instance($cm->id);
1052                         $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1053                     }
1055                     $strforums      = get_string('forums', 'forum');
1056                     $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
1057                     $canreply       = $userto->canpost[$discussion->id];
1058                     $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1060                     $posttext .= "\n \n";
1061                     $posttext .= '=====================================================================';
1062                     $posttext .= "\n \n";
1063                     $posttext .= "$shortname -> $strforums -> ".format_string($forum->name,true);
1064                     if ($discussion->name != $forum->name) {
1065                         $posttext  .= " -> ".format_string($discussion->name,true);
1066                     }
1067                     $posttext .= "\n";
1068                     $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1069                     $posttext .= "\n";
1071                     $posthtml .= "<p><font face=\"sans-serif\">".
1072                     "<a target=\"_blank\" href=\"$CFG->wwwroot/course/view.php?id=$course->id\">$shortname</a> -> ".
1073                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/index.php?id=$course->id\">$strforums</a> -> ".
1074                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/view.php?f=$forum->id\">".format_string($forum->name,true)."</a>";
1075                     if ($discussion->name == $forum->name) {
1076                         $posthtml .= "</font></p>";
1077                     } else {
1078                         $posthtml .= " -> <a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id\">".format_string($discussion->name,true)."</a></font></p>";
1079                     }
1080                     $posthtml .= '<p>';
1082                     $postsarray = $discussionposts[$discussionid];
1083                     sort($postsarray);
1084                     $sentcount = 0;
1086                     foreach ($postsarray as $postid) {
1087                         $post = $posts[$postid];
1089                         if (array_key_exists($post->userid, $users)) { // we might know him/her already
1090                             $userfrom = $users[$post->userid];
1091                             if (!isset($userfrom->idnumber)) {
1092                                 $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
1093                                 forum_cron_minimise_user_record($userfrom);
1094                             }
1096                         } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
1097                             forum_cron_minimise_user_record($userfrom);
1098                             if ($userscount <= FORUM_CRON_USER_CACHE) {
1099                                 $userscount++;
1100                                 $users[$userfrom->id] = $userfrom;
1101                             }
1103                         } else {
1104                             mtrace('Could not find user '.$post->userid);
1105                             continue;
1106                         }
1108                         if (!isset($userfrom->groups[$forum->id])) {
1109                             if (!isset($userfrom->groups)) {
1110                                 $userfrom->groups = array();
1111                                 if (isset($users[$userfrom->id])) {
1112                                     $users[$userfrom->id]->groups = array();
1113                                 }
1114                             }
1115                             $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
1116                             if (isset($users[$userfrom->id])) {
1117                                 $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
1118                             }
1119                         }
1121                         // Headers to help prevent auto-responders.
1122                         $userfrom->customheaders = array(
1123                                 "Precedence: Bulk",
1124                                 'X-Auto-Response-Suppress: All',
1125                                 'Auto-Submitted: auto-generated',
1126                             );
1128                         $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
1129                         if (!isset($userto->canpost[$discussion->id])) {
1130                             $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1131                         } else {
1132                             $canreply = $userto->canpost[$discussion->id];
1133                         }
1135                         $data = new \mod_forum\output\forum_post_email(
1136                                 $course,
1137                                 $cm,
1138                                 $forum,
1139                                 $discussion,
1140                                 $post,
1141                                 $userfrom,
1142                                 $userto,
1143                                 $canreply
1144                             );
1146                         if (!isset($userto->viewfullnames[$forum->id])) {
1147                             $data->viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
1148                         } else {
1149                             $data->viewfullnames = $userto->viewfullnames[$forum->id];
1150                         }
1152                         if ($maildigest == 2) {
1153                             // Subjects and link only.
1154                             $posttext .= $textdigestbasicout->render($data);
1155                             $posthtml .= $htmldigestbasicout->render($data);
1156                         } else {
1157                             // The full treatment.
1158                             $posttext .= $textdigestfullout->render($data);
1159                             $posthtml .= $htmldigestfullout->render($data);
1161                             // Create an array of postid's for this user to mark as read.
1162                             if (!$CFG->forum_usermarksread) {
1163                                 $userto->markposts[$post->id] = $post->id;
1164                             }
1165                         }
1166                         $sentcount++;
1167                     }
1168                     $footerlinks = array();
1169                     if ($canunsubscribe) {
1170                         $footerlinks[] = "<a href=\"$CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id\">" . get_string("unsubscribe", "forum") . "</a>";
1171                     } else {
1172                         $footerlinks[] = get_string("everyoneissubscribed", "forum");
1173                     }
1174                     $footerlinks[] = "<a href='{$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}'>" . get_string("digestmailpost", "forum") . '</a>';
1175                     $posthtml .= "\n<div class='mdl-right'><font size=\"1\">" . implode('&nbsp;', $footerlinks) . '</font></div>';
1176                     $posthtml .= '<hr size="1" noshade="noshade" /></p>';
1177                 }
1179                 if (empty($userto->mailformat) || $userto->mailformat != 1) {
1180                     // This user DOESN'T want to receive HTML
1181                     $posthtml = '';
1182                 }
1184                 $eventdata = new \core\message\message();
1185                 $eventdata->component           = 'mod_forum';
1186                 $eventdata->name                = 'digests';
1187                 $eventdata->userfrom            = core_user::get_noreply_user();
1188                 $eventdata->userto              = $userto;
1189                 $eventdata->subject             = $postsubject;
1190                 $eventdata->fullmessage         = $posttext;
1191                 $eventdata->fullmessageformat   = FORMAT_PLAIN;
1192                 $eventdata->fullmessagehtml     = $posthtml;
1193                 $eventdata->notification        = 1;
1194                 $eventdata->smallmessage        = get_string('smallmessagedigest', 'forum', $sentcount);
1195                 $mailresult = message_send($eventdata);
1197                 if (!$mailresult) {
1198                     mtrace("ERROR: mod/forum/cron.php: Could not send out digest mail to user $userto->id ".
1199                         "($userto->email)... not trying again.");
1200                 } else {
1201                     mtrace("success.");
1202                     $usermailcount++;
1204                     // Mark post as read if forum_usermarksread is set off
1205                     forum_tp_mark_posts_read($userto, $userto->markposts);
1206                 }
1207             }
1208         }
1209     /// We have finishied all digest emails, update $CFG->digestmailtimelast
1210         set_config('digestmailtimelast', $timenow);
1211     }
1213     cron_setup_user();
1215     if (!empty($usermailcount)) {
1216         mtrace(get_string('digestsentusers', 'forum', $usermailcount));
1217     }
1219     if (!empty($CFG->forum_lastreadclean)) {
1220         $timenow = time();
1221         if ($CFG->forum_lastreadclean + (24*3600) < $timenow) {
1222             set_config('forum_lastreadclean', $timenow);
1223             mtrace('Removing old forum read tracking info...');
1224             forum_tp_clean_read_records();
1225         }
1226     } else {
1227         set_config('forum_lastreadclean', time());
1228     }
1230     return true;
1233 /**
1234  *
1235  * @param object $course
1236  * @param object $user
1237  * @param object $mod TODO this is not used in this function, refactor
1238  * @param object $forum
1239  * @return object A standard object with 2 variables: info (number of posts for this user) and time (last modified)
1240  */
1241 function forum_user_outline($course, $user, $mod, $forum) {
1242     global $CFG;
1243     require_once("$CFG->libdir/gradelib.php");
1244     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1245     if (empty($grades->items[0]->grades)) {
1246         $grade = false;
1247     } else {
1248         $grade = reset($grades->items[0]->grades);
1249     }
1251     $count = forum_count_user_posts($forum->id, $user->id);
1253     if ($count && $count->postcount > 0) {
1254         $result = new stdClass();
1255         $result->info = get_string("numposts", "forum", $count->postcount);
1256         $result->time = $count->lastpost;
1257         if ($grade) {
1258             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1259         }
1260         return $result;
1261     } else if ($grade) {
1262         $result = new stdClass();
1263         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1265         //datesubmitted == time created. dategraded == time modified or time overridden
1266         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1267         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1268         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1269             $result->time = $grade->dategraded;
1270         } else {
1271             $result->time = $grade->datesubmitted;
1272         }
1274         return $result;
1275     }
1276     return NULL;
1280 /**
1281  * @global object
1282  * @global object
1283  * @param object $coure
1284  * @param object $user
1285  * @param object $mod
1286  * @param object $forum
1287  */
1288 function forum_user_complete($course, $user, $mod, $forum) {
1289     global $CFG,$USER, $OUTPUT;
1290     require_once("$CFG->libdir/gradelib.php");
1292     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1293     if (!empty($grades->items[0]->grades)) {
1294         $grade = reset($grades->items[0]->grades);
1295         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1296         if ($grade->str_feedback) {
1297             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1298         }
1299     }
1301     if ($posts = forum_get_user_posts($forum->id, $user->id)) {
1303         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $course->id)) {
1304             print_error('invalidcoursemodule');
1305         }
1306         $discussions = forum_get_user_involved_discussions($forum->id, $user->id);
1308         foreach ($posts as $post) {
1309             if (!isset($discussions[$post->discussion])) {
1310                 continue;
1311             }
1312             $discussion = $discussions[$post->discussion];
1314             forum_print_post($post, $discussion, $forum, $cm, $course, false, false, false);
1315         }
1316     } else {
1317         echo "<p>".get_string("noposts", "forum")."</p>";
1318     }
1321 /**
1322  * Filters the forum discussions according to groups membership and config.
1323  *
1324  * @since  Moodle 2.8, 2.7.1, 2.6.4
1325  * @param  array $discussions Discussions with new posts array
1326  * @return array Forums with the number of new posts
1327  */
1328 function forum_filter_user_groups_discussions($discussions) {
1330     // Group the remaining discussions posts by their forumid.
1331     $filteredforums = array();
1333     // Discard not visible groups.
1334     foreach ($discussions as $discussion) {
1336         // Course data is already cached.
1337         $instances = get_fast_modinfo($discussion->course)->get_instances();
1338         $forum = $instances['forum'][$discussion->forum];
1340         // Continue if the user should not see this discussion.
1341         if (!forum_is_user_group_discussion($forum, $discussion->groupid)) {
1342             continue;
1343         }
1345         // Grouping results by forum.
1346         if (empty($filteredforums[$forum->instance])) {
1347             $filteredforums[$forum->instance] = new stdClass();
1348             $filteredforums[$forum->instance]->id = $forum->id;
1349             $filteredforums[$forum->instance]->count = 0;
1350         }
1351         $filteredforums[$forum->instance]->count += $discussion->count;
1353     }
1355     return $filteredforums;
1358 /**
1359  * Returns whether the discussion group is visible by the current user or not.
1360  *
1361  * @since Moodle 2.8, 2.7.1, 2.6.4
1362  * @param cm_info $cm The discussion course module
1363  * @param int $discussiongroupid The discussion groupid
1364  * @return bool
1365  */
1366 function forum_is_user_group_discussion(cm_info $cm, $discussiongroupid) {
1368     if ($discussiongroupid == -1 || $cm->effectivegroupmode != SEPARATEGROUPS) {
1369         return true;
1370     }
1372     if (isguestuser()) {
1373         return false;
1374     }
1376     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id)) ||
1377             in_array($discussiongroupid, $cm->get_modinfo()->get_groups($cm->groupingid))) {
1378         return true;
1379     }
1381     return false;
1384 /**
1385  * @global object
1386  * @global object
1387  * @global object
1388  * @param array $courses
1389  * @param array $htmlarray
1390  */
1391 function forum_print_overview($courses,&$htmlarray) {
1392     global $USER, $CFG, $DB, $SESSION;
1394     if (empty($courses) || !is_array($courses) || count($courses) == 0) {
1395         return array();
1396     }
1398     if (!$forums = get_all_instances_in_courses('forum',$courses)) {
1399         return;
1400     }
1402     // Courses to search for new posts
1403     $coursessqls = array();
1404     $params = array();
1405     foreach ($courses as $course) {
1407         // If the user has never entered into the course all posts are pending
1408         if ($course->lastaccess == 0) {
1409             $coursessqls[] = '(d.course = ?)';
1410             $params[] = $course->id;
1412         // Only posts created after the course last access
1413         } else {
1414             $coursessqls[] = '(d.course = ? AND p.created > ?)';
1415             $params[] = $course->id;
1416             $params[] = $course->lastaccess;
1417         }
1418     }
1419     $params[] = $USER->id;
1420     $coursessql = implode(' OR ', $coursessqls);
1422     $sql = "SELECT d.id, d.forum, d.course, d.groupid, COUNT(*) as count "
1423                 .'FROM {forum_discussions} d '
1424                 .'JOIN {forum_posts} p ON p.discussion = d.id '
1425                 ."WHERE ($coursessql) "
1426                 .'AND p.userid != ? '
1427                 .'AND (d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?)) '
1428                 .'GROUP BY d.id, d.forum, d.course, d.groupid '
1429                 .'ORDER BY d.course, d.forum';
1430     $params[] = time();
1431     $params[] = time();
1433     // Avoid warnings.
1434     if (!$discussions = $DB->get_records_sql($sql, $params)) {
1435         $discussions = array();
1436     }
1438     $forumsnewposts = forum_filter_user_groups_discussions($discussions);
1440     // also get all forum tracking stuff ONCE.
1441     $trackingforums = array();
1442     foreach ($forums as $forum) {
1443         if (forum_tp_can_track_forums($forum)) {
1444             $trackingforums[$forum->id] = $forum;
1445         }
1446     }
1448     if (count($trackingforums) > 0) {
1449         $cutoffdate = isset($CFG->forum_oldpostdays) ? (time() - ($CFG->forum_oldpostdays*24*60*60)) : 0;
1450         $sql = 'SELECT d.forum,d.course,COUNT(p.id) AS count '.
1451             ' FROM {forum_posts} p '.
1452             ' JOIN {forum_discussions} d ON p.discussion = d.id '.
1453             ' LEFT JOIN {forum_read} r ON r.postid = p.id AND r.userid = ? WHERE (';
1454         $params = array($USER->id);
1456         foreach ($trackingforums as $track) {
1457             $sql .= '(d.forum = ? AND (d.groupid = -1 OR d.groupid = 0 OR d.groupid = ?)) OR ';
1458             $params[] = $track->id;
1459             if (isset($SESSION->currentgroup[$track->course])) {
1460                 $groupid =  $SESSION->currentgroup[$track->course];
1461             } else {
1462                 // get first groupid
1463                 $groupids = groups_get_all_groups($track->course, $USER->id);
1464                 if ($groupids) {
1465                     reset($groupids);
1466                     $groupid = key($groupids);
1467                     $SESSION->currentgroup[$track->course] = $groupid;
1468                 } else {
1469                     $groupid = 0;
1470                 }
1471                 unset($groupids);
1472             }
1473             $params[] = $groupid;
1474         }
1475         $sql = substr($sql,0,-3); // take off the last OR
1476         $sql .= ') AND p.modified >= ? AND r.id is NULL ';
1477         $sql .= 'AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)) ';
1478         $sql .= 'GROUP BY d.forum,d.course';
1479         $params[] = $cutoffdate;
1480         $params[] = time();
1481         $params[] = time();
1483         if (!$unread = $DB->get_records_sql($sql, $params)) {
1484             $unread = array();
1485         }
1486     } else {
1487         $unread = array();
1488     }
1490     if (empty($unread) and empty($forumsnewposts)) {
1491         return;
1492     }
1494     $strforum = get_string('modulename','forum');
1496     foreach ($forums as $forum) {
1497         $str = '';
1498         $count = 0;
1499         $thisunread = 0;
1500         $showunread = false;
1501         // either we have something from logs, or trackposts, or nothing.
1502         if (array_key_exists($forum->id, $forumsnewposts) && !empty($forumsnewposts[$forum->id])) {
1503             $count = $forumsnewposts[$forum->id]->count;
1504         }
1505         if (array_key_exists($forum->id,$unread)) {
1506             $thisunread = $unread[$forum->id]->count;
1507             $showunread = true;
1508         }
1509         if ($count > 0 || $thisunread > 0) {
1510             $str .= '<div class="overview forum"><div class="name">'.$strforum.': <a title="'.$strforum.'" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.
1511                 $forum->name.'</a></div>';
1512             $str .= '<div class="info"><span class="postsincelogin">';
1513             $str .= get_string('overviewnumpostssince', 'forum', $count)."</span>";
1514             if (!empty($showunread)) {
1515                 $str .= '<div class="unreadposts">'.get_string('overviewnumunread', 'forum', $thisunread).'</div>';
1516             }
1517             $str .= '</div></div>';
1518         }
1519         if (!empty($str)) {
1520             if (!array_key_exists($forum->course,$htmlarray)) {
1521                 $htmlarray[$forum->course] = array();
1522             }
1523             if (!array_key_exists('forum',$htmlarray[$forum->course])) {
1524                 $htmlarray[$forum->course]['forum'] = ''; // initialize, avoid warnings
1525             }
1526             $htmlarray[$forum->course]['forum'] .= $str;
1527         }
1528     }
1531 /**
1532  * Given a course and a date, prints a summary of all the new
1533  * messages posted in the course since that date
1534  *
1535  * @global object
1536  * @global object
1537  * @global object
1538  * @uses CONTEXT_MODULE
1539  * @uses VISIBLEGROUPS
1540  * @param object $course
1541  * @param bool $viewfullnames capability
1542  * @param int $timestart
1543  * @return bool success
1544  */
1545 function forum_print_recent_activity($course, $viewfullnames, $timestart) {
1546     global $CFG, $USER, $DB, $OUTPUT;
1548     // do not use log table if possible, it may be huge and is expensive to join with other tables
1550     $allnamefields = user_picture::fields('u', null, 'duserid');
1551     if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
1552                                               d.timestart, d.timeend, $allnamefields
1553                                          FROM {forum_posts} p
1554                                               JOIN {forum_discussions} d ON d.id = p.discussion
1555                                               JOIN {forum} f             ON f.id = d.forum
1556                                               JOIN {user} u              ON u.id = p.userid
1557                                         WHERE p.created > ? AND f.course = ?
1558                                      ORDER BY p.id ASC", array($timestart, $course->id))) { // order by initial posting date
1559          return false;
1560     }
1562     $modinfo = get_fast_modinfo($course);
1564     $groupmodes = array();
1565     $cms    = array();
1567     $strftimerecent = get_string('strftimerecent');
1569     $printposts = array();
1570     foreach ($posts as $post) {
1571         if (!isset($modinfo->instances['forum'][$post->forum])) {
1572             // not visible
1573             continue;
1574         }
1575         $cm = $modinfo->instances['forum'][$post->forum];
1576         if (!$cm->uservisible) {
1577             continue;
1578         }
1579         $context = context_module::instance($cm->id);
1581         if (!has_capability('mod/forum:viewdiscussion', $context)) {
1582             continue;
1583         }
1585         if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
1586           and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
1587             if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1588                 continue;
1589             }
1590         }
1592         // Check that the user can see the discussion.
1593         if (forum_is_user_group_discussion($cm, $post->groupid)) {
1594             $printposts[] = $post;
1595         }
1597     }
1598     unset($posts);
1600     if (!$printposts) {
1601         return false;
1602     }
1604     echo $OUTPUT->heading(get_string('newforumposts', 'forum').':', 3);
1605     $list = html_writer::start_tag('ul', ['class' => 'unlist']);
1607     foreach ($printposts as $post) {
1608         $subjectclass = empty($post->parent) ? ' bold' : '';
1609         $authorhidden = forum_is_author_hidden($post, (object) ['type' => $post->forumtype]);
1611         $list .= html_writer::start_tag('li');
1612         $list .= html_writer::start_div('head');
1613         $list .= html_writer::div(userdate($post->modified, $strftimerecent), 'date');
1614         if (!$authorhidden) {
1615             $list .= html_writer::div(fullname($post, $viewfullnames), 'name');
1616         }
1617         $list .= html_writer::end_div(); // Head.
1619         $list .= html_writer::start_div('info' . $subjectclass);
1620         $discussionurl = new moodle_url('/mod/forum/discuss.php', ['d' => $post->discussion]);
1621         if (!empty($post->parent)) {
1622             $discussionurl->param('parent', $post->parent);
1623             $discussionurl->set_anchor('p'. $post->id);
1624         }
1625         $post->subject = break_up_long_words(format_string($post->subject, true));
1626         $list .= html_writer::link($discussionurl, $post->subject);
1627         $list .= html_writer::end_div(); // Info.
1628         $list .= html_writer::end_tag('li');
1629     }
1631     $list .= html_writer::end_tag('ul');
1632     echo $list;
1634     return true;
1637 /**
1638  * Return grade for given user or all users.
1639  *
1640  * @global object
1641  * @global object
1642  * @param object $forum
1643  * @param int $userid optional user id, 0 means all users
1644  * @return array array of grades, false if none
1645  */
1646 function forum_get_user_grades($forum, $userid = 0) {
1647     global $CFG;
1649     require_once($CFG->dirroot.'/rating/lib.php');
1651     $ratingoptions = new stdClass;
1652     $ratingoptions->component = 'mod_forum';
1653     $ratingoptions->ratingarea = 'post';
1655     //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?
1656     $ratingoptions->modulename = 'forum';
1657     $ratingoptions->moduleid   = $forum->id;
1658     $ratingoptions->userid = $userid;
1659     $ratingoptions->aggregationmethod = $forum->assessed;
1660     $ratingoptions->scaleid = $forum->scale;
1661     $ratingoptions->itemtable = 'forum_posts';
1662     $ratingoptions->itemtableusercolumn = 'userid';
1664     $rm = new rating_manager();
1665     return $rm->get_user_grades($ratingoptions);
1668 /**
1669  * Update activity grades
1670  *
1671  * @category grade
1672  * @param object $forum
1673  * @param int $userid specific user only, 0 means all
1674  * @param boolean $nullifnone return null if grade does not exist
1675  * @return void
1676  */
1677 function forum_update_grades($forum, $userid=0, $nullifnone=true) {
1678     global $CFG, $DB;
1679     require_once($CFG->libdir.'/gradelib.php');
1681     if (!$forum->assessed) {
1682         forum_grade_item_update($forum);
1684     } else if ($grades = forum_get_user_grades($forum, $userid)) {
1685         forum_grade_item_update($forum, $grades);
1687     } else if ($userid and $nullifnone) {
1688         $grade = new stdClass();
1689         $grade->userid   = $userid;
1690         $grade->rawgrade = NULL;
1691         forum_grade_item_update($forum, $grade);
1693     } else {
1694         forum_grade_item_update($forum);
1695     }
1698 /**
1699  * Create/update grade item for given forum
1700  *
1701  * @category grade
1702  * @uses GRADE_TYPE_NONE
1703  * @uses GRADE_TYPE_VALUE
1704  * @uses GRADE_TYPE_SCALE
1705  * @param stdClass $forum Forum object with extra cmidnumber
1706  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1707  * @return int 0 if ok
1708  */
1709 function forum_grade_item_update($forum, $grades=NULL) {
1710     global $CFG;
1711     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
1712         require_once($CFG->libdir.'/gradelib.php');
1713     }
1715     $params = array('itemname'=>$forum->name, 'idnumber'=>$forum->cmidnumber);
1717     if (!$forum->assessed or $forum->scale == 0) {
1718         $params['gradetype'] = GRADE_TYPE_NONE;
1720     } else if ($forum->scale > 0) {
1721         $params['gradetype'] = GRADE_TYPE_VALUE;
1722         $params['grademax']  = $forum->scale;
1723         $params['grademin']  = 0;
1725     } else if ($forum->scale < 0) {
1726         $params['gradetype'] = GRADE_TYPE_SCALE;
1727         $params['scaleid']   = -$forum->scale;
1728     }
1730     if ($grades  === 'reset') {
1731         $params['reset'] = true;
1732         $grades = NULL;
1733     }
1735     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, $grades, $params);
1738 /**
1739  * Delete grade item for given forum
1740  *
1741  * @category grade
1742  * @param stdClass $forum Forum object
1743  * @return grade_item
1744  */
1745 function forum_grade_item_delete($forum) {
1746     global $CFG;
1747     require_once($CFG->libdir.'/gradelib.php');
1749     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, NULL, array('deleted'=>1));
1753 /**
1754  * This function returns if a scale is being used by one forum
1755  *
1756  * @global object
1757  * @param int $forumid
1758  * @param int $scaleid negative number
1759  * @return bool
1760  */
1761 function forum_scale_used ($forumid,$scaleid) {
1762     global $DB;
1763     $return = false;
1765     $rec = $DB->get_record("forum",array("id" => "$forumid","scale" => "-$scaleid"));
1767     if (!empty($rec) && !empty($scaleid)) {
1768         $return = true;
1769     }
1771     return $return;
1774 /**
1775  * Checks if scale is being used by any instance of forum
1776  *
1777  * This is used to find out if scale used anywhere
1778  *
1779  * @global object
1780  * @param $scaleid int
1781  * @return boolean True if the scale is used by any forum
1782  */
1783 function forum_scale_used_anywhere($scaleid) {
1784     global $DB;
1785     if ($scaleid and $DB->record_exists('forum', array('scale' => -$scaleid))) {
1786         return true;
1787     } else {
1788         return false;
1789     }
1792 // SQL FUNCTIONS ///////////////////////////////////////////////////////////
1794 /**
1795  * Gets a post with all info ready for forum_print_post
1796  * Most of these joins are just to get the forum id
1797  *
1798  * @global object
1799  * @global object
1800  * @param int $postid
1801  * @return mixed array of posts or false
1802  */
1803 function forum_get_post_full($postid) {
1804     global $CFG, $DB;
1806     $allnames = get_all_user_name_fields(true, 'u');
1807     return $DB->get_record_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1808                              FROM {forum_posts} p
1809                                   JOIN {forum_discussions} d ON p.discussion = d.id
1810                                   LEFT JOIN {user} u ON p.userid = u.id
1811                             WHERE p.id = ?", array($postid));
1814 /**
1815  * Gets all posts in discussion including top parent.
1816  *
1817  * @global object
1818  * @global object
1819  * @global object
1820  * @param int $discussionid
1821  * @param string $sort
1822  * @param bool $tracking does user track the forum?
1823  * @return array of posts
1824  */
1825 function forum_get_all_discussion_posts($discussionid, $sort, $tracking=false) {
1826     global $CFG, $DB, $USER;
1828     $tr_sel  = "";
1829     $tr_join = "";
1830     $params = array();
1832     if ($tracking) {
1833         $tr_sel  = ", fr.id AS postread";
1834         $tr_join = "LEFT JOIN {forum_read} fr ON (fr.postid = p.id AND fr.userid = ?)";
1835         $params[] = $USER->id;
1836     }
1838     $allnames = get_all_user_name_fields(true, 'u');
1839     $params[] = $discussionid;
1840     if (!$posts = $DB->get_records_sql("SELECT p.*, $allnames, u.email, u.picture, u.imagealt $tr_sel
1841                                      FROM {forum_posts} p
1842                                           LEFT JOIN {user} u ON p.userid = u.id
1843                                           $tr_join
1844                                     WHERE p.discussion = ?
1845                                  ORDER BY $sort", $params)) {
1846         return array();
1847     }
1849     foreach ($posts as $pid=>$p) {
1850         if ($tracking) {
1851             if (forum_tp_is_post_old($p)) {
1852                  $posts[$pid]->postread = true;
1853             }
1854         }
1855         if (!$p->parent) {
1856             continue;
1857         }
1858         if (!isset($posts[$p->parent])) {
1859             continue; // parent does not exist??
1860         }
1861         if (!isset($posts[$p->parent]->children)) {
1862             $posts[$p->parent]->children = array();
1863         }
1864         $posts[$p->parent]->children[$pid] =& $posts[$pid];
1865     }
1867     // Start with the last child of the first post.
1868     $post = &$posts[reset($posts)->id];
1870     $lastpost = false;
1871     while (!$lastpost) {
1872         if (!isset($post->children)) {
1873             $post->lastpost = true;
1874             $lastpost = true;
1875         } else {
1876              // Go to the last child of this post.
1877             $post = &$posts[end($post->children)->id];
1878         }
1879     }
1881     return $posts;
1884 /**
1885  * An array of forum objects that the user is allowed to read/search through.
1886  *
1887  * @global object
1888  * @global object
1889  * @global object
1890  * @param int $userid
1891  * @param int $courseid if 0, we look for forums throughout the whole site.
1892  * @return array of forum objects, or false if no matches
1893  *         Forum objects have the following attributes:
1894  *         id, type, course, cmid, cmvisible, cmgroupmode, accessallgroups,
1895  *         viewhiddentimedposts
1896  */
1897 function forum_get_readable_forums($userid, $courseid=0) {
1899     global $CFG, $DB, $USER;
1900     require_once($CFG->dirroot.'/course/lib.php');
1902     if (!$forummod = $DB->get_record('modules', array('name' => 'forum'))) {
1903         print_error('notinstalled', 'forum');
1904     }
1906     if ($courseid) {
1907         $courses = $DB->get_records('course', array('id' => $courseid));
1908     } else {
1909         // If no course is specified, then the user can see SITE + his courses.
1910         $courses1 = $DB->get_records('course', array('id' => SITEID));
1911         $courses2 = enrol_get_users_courses($userid, true, array('modinfo'));
1912         $courses = array_merge($courses1, $courses2);
1913     }
1914     if (!$courses) {
1915         return array();
1916     }
1918     $readableforums = array();
1920     foreach ($courses as $course) {
1922         $modinfo = get_fast_modinfo($course);
1924         if (empty($modinfo->instances['forum'])) {
1925             // hmm, no forums?
1926             continue;
1927         }
1929         $courseforums = $DB->get_records('forum', array('course' => $course->id));
1931         foreach ($modinfo->instances['forum'] as $forumid => $cm) {
1932             if (!$cm->uservisible or !isset($courseforums[$forumid])) {
1933                 continue;
1934             }
1935             $context = context_module::instance($cm->id);
1936             $forum = $courseforums[$forumid];
1937             $forum->context = $context;
1938             $forum->cm = $cm;
1940             if (!has_capability('mod/forum:viewdiscussion', $context)) {
1941                 continue;
1942             }
1944          /// group access
1945             if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
1947                 $forum->onlygroups = $modinfo->get_groups($cm->groupingid);
1948                 $forum->onlygroups[] = -1;
1949             }
1951         /// hidden timed discussions
1952             $forum->viewhiddentimedposts = true;
1953             if (!empty($CFG->forum_enabletimedposts)) {
1954                 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1955                     $forum->viewhiddentimedposts = false;
1956                 }
1957             }
1959         /// qanda access
1960             if ($forum->type == 'qanda'
1961                     && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
1963                 // We need to check whether the user has posted in the qanda forum.
1964                 $forum->onlydiscussions = array();  // Holds discussion ids for the discussions
1965                                                     // the user is allowed to see in this forum.
1966                 if ($discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $USER->id)) {
1967                     foreach ($discussionspostedin as $d) {
1968                         $forum->onlydiscussions[] = $d->id;
1969                     }
1970                 }
1971             }
1973             $readableforums[$forum->id] = $forum;
1974         }
1976         unset($modinfo);
1978     } // End foreach $courses
1980     return $readableforums;
1983 /**
1984  * Returns a list of posts found using an array of search terms.
1985  *
1986  * @global object
1987  * @global object
1988  * @global object
1989  * @param array $searchterms array of search terms, e.g. word +word -word
1990  * @param int $courseid if 0, we search through the whole site
1991  * @param int $limitfrom
1992  * @param int $limitnum
1993  * @param int &$totalcount
1994  * @param string $extrasql
1995  * @return array|bool Array of posts found or false
1996  */
1997 function forum_search_posts($searchterms, $courseid=0, $limitfrom=0, $limitnum=50,
1998                             &$totalcount, $extrasql='') {
1999     global $CFG, $DB, $USER;
2000     require_once($CFG->libdir.'/searchlib.php');
2002     $forums = forum_get_readable_forums($USER->id, $courseid);
2004     if (count($forums) == 0) {
2005         $totalcount = 0;
2006         return false;
2007     }
2009     $now = round(time(), -2); // db friendly
2011     $fullaccess = array();
2012     $where = array();
2013     $params = array();
2015     foreach ($forums as $forumid => $forum) {
2016         $select = array();
2018         if (!$forum->viewhiddentimedposts) {
2019             $select[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
2020             $params = array_merge($params, array('userid'.$forumid=>$USER->id, 'timestart'.$forumid=>$now, 'timeend'.$forumid=>$now));
2021         }
2023         $cm = $forum->cm;
2024         $context = $forum->context;
2026         if ($forum->type == 'qanda'
2027             && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
2028             if (!empty($forum->onlydiscussions)) {
2029                 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forum->onlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
2030                 $params = array_merge($params, $discussionid_params);
2031                 $select[] = "(d.id $discussionid_sql OR p.parent = 0)";
2032             } else {
2033                 $select[] = "p.parent = 0";
2034             }
2035         }
2037         if (!empty($forum->onlygroups)) {
2038             list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($forum->onlygroups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
2039             $params = array_merge($params, $groupid_params);
2040             $select[] = "d.groupid $groupid_sql";
2041         }
2043         if ($select) {
2044             $selects = implode(" AND ", $select);
2045             $where[] = "(d.forum = :forum{$forumid} AND $selects)";
2046             $params['forum'.$forumid] = $forumid;
2047         } else {
2048             $fullaccess[] = $forumid;
2049         }
2050     }
2052     if ($fullaccess) {
2053         list($fullid_sql, $fullid_params) = $DB->get_in_or_equal($fullaccess, SQL_PARAMS_NAMED, 'fula');
2054         $params = array_merge($params, $fullid_params);
2055         $where[] = "(d.forum $fullid_sql)";
2056     }
2058     $selectdiscussion = "(".implode(" OR ", $where).")";
2060     $messagesearch = '';
2061     $searchstring = '';
2063     // Need to concat these back together for parser to work.
2064     foreach($searchterms as $searchterm){
2065         if ($searchstring != '') {
2066             $searchstring .= ' ';
2067         }
2068         $searchstring .= $searchterm;
2069     }
2071     // We need to allow quoted strings for the search. The quotes *should* be stripped
2072     // by the parser, but this should be examined carefully for security implications.
2073     $searchstring = str_replace("\\\"","\"",$searchstring);
2074     $parser = new search_parser();
2075     $lexer = new search_lexer($parser);
2077     if ($lexer->parse($searchstring)) {
2078         $parsearray = $parser->get_parsed_array();
2079         list($messagesearch, $msparams) = search_generate_SQL($parsearray, 'p.message', 'p.subject',
2080                                                               'p.userid', 'u.id', 'u.firstname',
2081                                                               'u.lastname', 'p.modified', 'd.forum');
2082         $params = array_merge($params, $msparams);
2083     }
2085     $fromsql = "{forum_posts} p,
2086                   {forum_discussions} d,
2087                   {user} u";
2089     $selectsql = " $messagesearch
2090                AND p.discussion = d.id
2091                AND p.userid = u.id
2092                AND $selectdiscussion
2093                    $extrasql";
2095     $countsql = "SELECT COUNT(*)
2096                    FROM $fromsql
2097                   WHERE $selectsql";
2099     $allnames = get_all_user_name_fields(true, 'u');
2100     $searchsql = "SELECT p.*,
2101                          d.forum,
2102                          $allnames,
2103                          u.email,
2104                          u.picture,
2105                          u.imagealt
2106                     FROM $fromsql
2107                    WHERE $selectsql
2108                 ORDER BY p.modified DESC";
2110     $totalcount = $DB->count_records_sql($countsql, $params);
2112     return $DB->get_records_sql($searchsql, $params, $limitfrom, $limitnum);
2115 /**
2116  * Returns a list of all new posts that have not been mailed yet
2117  *
2118  * @param int $starttime posts created after this time
2119  * @param int $endtime posts created before this
2120  * @param int $now used for timed discussions only
2121  * @return array
2122  */
2123 function forum_get_unmailed_posts($starttime, $endtime, $now=null) {
2124     global $CFG, $DB;
2126     $params = array();
2127     $params['mailed'] = FORUM_MAILED_PENDING;
2128     $params['ptimestart'] = $starttime;
2129     $params['ptimeend'] = $endtime;
2130     $params['mailnow'] = 1;
2132     if (!empty($CFG->forum_enabletimedposts)) {
2133         if (empty($now)) {
2134             $now = time();
2135         }
2136         $selectsql = "AND (p.created >= :ptimestart OR d.timestart >= :pptimestart)";
2137         $params['pptimestart'] = $starttime;
2138         $timedsql = "AND (d.timestart < :dtimestart AND (d.timeend = 0 OR d.timeend > :dtimeend))";
2139         $params['dtimestart'] = $now;
2140         $params['dtimeend'] = $now;
2141     } else {
2142         $timedsql = "";
2143         $selectsql = "AND p.created >= :ptimestart";
2144     }
2146     return $DB->get_records_sql("SELECT p.*, d.course, d.forum
2147                                  FROM {forum_posts} p
2148                                  JOIN {forum_discussions} d ON d.id = p.discussion
2149                                  WHERE p.mailed = :mailed
2150                                  $selectsql
2151                                  AND (p.created < :ptimeend OR p.mailnow = :mailnow)
2152                                  $timedsql
2153                                  ORDER BY p.modified ASC", $params);
2156 /**
2157  * Marks posts before a certain time as being mailed already
2158  *
2159  * @global object
2160  * @global object
2161  * @param int $endtime
2162  * @param int $now Defaults to time()
2163  * @return bool
2164  */
2165 function forum_mark_old_posts_as_mailed($endtime, $now=null) {
2166     global $CFG, $DB;
2168     if (empty($now)) {
2169         $now = time();
2170     }
2172     $params = array();
2173     $params['mailedsuccess'] = FORUM_MAILED_SUCCESS;
2174     $params['now'] = $now;
2175     $params['endtime'] = $endtime;
2176     $params['mailnow'] = 1;
2177     $params['mailedpending'] = FORUM_MAILED_PENDING;
2179     if (empty($CFG->forum_enabletimedposts)) {
2180         return $DB->execute("UPDATE {forum_posts}
2181                              SET mailed = :mailedsuccess
2182                              WHERE (created < :endtime OR mailnow = :mailnow)
2183                              AND mailed = :mailedpending", $params);
2184     } else {
2185         return $DB->execute("UPDATE {forum_posts}
2186                              SET mailed = :mailedsuccess
2187                              WHERE discussion NOT IN (SELECT d.id
2188                                                       FROM {forum_discussions} d
2189                                                       WHERE d.timestart > :now)
2190                              AND (created < :endtime OR mailnow = :mailnow)
2191                              AND mailed = :mailedpending", $params);
2192     }
2195 /**
2196  * Get all the posts for a user in a forum suitable for forum_print_post
2197  *
2198  * @global object
2199  * @global object
2200  * @uses CONTEXT_MODULE
2201  * @return array
2202  */
2203 function forum_get_user_posts($forumid, $userid) {
2204     global $CFG, $DB;
2206     $timedsql = "";
2207     $params = array($forumid, $userid);
2209     if (!empty($CFG->forum_enabletimedposts)) {
2210         $cm = get_coursemodule_from_instance('forum', $forumid);
2211         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2212             $now = time();
2213             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2214             $params[] = $now;
2215             $params[] = $now;
2216         }
2217     }
2219     $allnames = get_all_user_name_fields(true, 'u');
2220     return $DB->get_records_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
2221                               FROM {forum} f
2222                                    JOIN {forum_discussions} d ON d.forum = f.id
2223                                    JOIN {forum_posts} p       ON p.discussion = d.id
2224                                    JOIN {user} u              ON u.id = p.userid
2225                              WHERE f.id = ?
2226                                    AND p.userid = ?
2227                                    $timedsql
2228                           ORDER BY p.modified ASC", $params);
2231 /**
2232  * Get all the discussions user participated in
2233  *
2234  * @global object
2235  * @global object
2236  * @uses CONTEXT_MODULE
2237  * @param int $forumid
2238  * @param int $userid
2239  * @return array Array or false
2240  */
2241 function forum_get_user_involved_discussions($forumid, $userid) {
2242     global $CFG, $DB;
2244     $timedsql = "";
2245     $params = array($forumid, $userid);
2246     if (!empty($CFG->forum_enabletimedposts)) {
2247         $cm = get_coursemodule_from_instance('forum', $forumid);
2248         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2249             $now = time();
2250             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2251             $params[] = $now;
2252             $params[] = $now;
2253         }
2254     }
2256     return $DB->get_records_sql("SELECT DISTINCT d.*
2257                               FROM {forum} f
2258                                    JOIN {forum_discussions} d ON d.forum = f.id
2259                                    JOIN {forum_posts} p       ON p.discussion = d.id
2260                              WHERE f.id = ?
2261                                    AND p.userid = ?
2262                                    $timedsql", $params);
2265 /**
2266  * Get all the posts for a user in a forum suitable for forum_print_post
2267  *
2268  * @global object
2269  * @global object
2270  * @param int $forumid
2271  * @param int $userid
2272  * @return array of counts or false
2273  */
2274 function forum_count_user_posts($forumid, $userid) {
2275     global $CFG, $DB;
2277     $timedsql = "";
2278     $params = array($forumid, $userid);
2279     if (!empty($CFG->forum_enabletimedposts)) {
2280         $cm = get_coursemodule_from_instance('forum', $forumid);
2281         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2282             $now = time();
2283             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2284             $params[] = $now;
2285             $params[] = $now;
2286         }
2287     }
2289     return $DB->get_record_sql("SELECT COUNT(p.id) AS postcount, MAX(p.modified) AS lastpost
2290                              FROM {forum} f
2291                                   JOIN {forum_discussions} d ON d.forum = f.id
2292                                   JOIN {forum_posts} p       ON p.discussion = d.id
2293                                   JOIN {user} u              ON u.id = p.userid
2294                             WHERE f.id = ?
2295                                   AND p.userid = ?
2296                                   $timedsql", $params);
2299 /**
2300  * Given a log entry, return the forum post details for it.
2301  *
2302  * @global object
2303  * @global object
2304  * @param object $log
2305  * @return array|null
2306  */
2307 function forum_get_post_from_log($log) {
2308     global $CFG, $DB;
2310     $allnames = get_all_user_name_fields(true, 'u');
2311     if ($log->action == "add post") {
2313         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2314                                  FROM {forum_discussions} d,
2315                                       {forum_posts} p,
2316                                       {forum} f,
2317                                       {user} u
2318                                 WHERE p.id = ?
2319                                   AND d.id = p.discussion
2320                                   AND p.userid = u.id
2321                                   AND u.deleted <> '1'
2322                                   AND f.id = d.forum", array($log->info));
2325     } else if ($log->action == "add discussion") {
2327         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2328                                  FROM {forum_discussions} d,
2329                                       {forum_posts} p,
2330                                       {forum} f,
2331                                       {user} u
2332                                 WHERE d.id = ?
2333                                   AND d.firstpost = p.id
2334                                   AND p.userid = u.id
2335                                   AND u.deleted <> '1'
2336                                   AND f.id = d.forum", array($log->info));
2337     }
2338     return NULL;
2341 /**
2342  * Given a discussion id, return the first post from the discussion
2343  *
2344  * @global object
2345  * @global object
2346  * @param int $dicsussionid
2347  * @return array
2348  */
2349 function forum_get_firstpost_from_discussion($discussionid) {
2350     global $CFG, $DB;
2352     return $DB->get_record_sql("SELECT p.*
2353                              FROM {forum_discussions} d,
2354                                   {forum_posts} p
2355                             WHERE d.id = ?
2356                               AND d.firstpost = p.id ", array($discussionid));
2359 /**
2360  * Returns an array of counts of replies to each discussion
2361  *
2362  * @global object
2363  * @global object
2364  * @param int $forumid
2365  * @param string $forumsort
2366  * @param int $limit
2367  * @param int $page
2368  * @param int $perpage
2369  * @return array
2370  */
2371 function forum_count_discussion_replies($forumid, $forumsort="", $limit=-1, $page=-1, $perpage=0) {
2372     global $CFG, $DB;
2374     if ($limit > 0) {
2375         $limitfrom = 0;
2376         $limitnum  = $limit;
2377     } else if ($page != -1) {
2378         $limitfrom = $page*$perpage;
2379         $limitnum  = $perpage;
2380     } else {
2381         $limitfrom = 0;
2382         $limitnum  = 0;
2383     }
2385     if ($forumsort == "") {
2386         $orderby = "";
2387         $groupby = "";
2389     } else {
2390         $orderby = "ORDER BY $forumsort";
2391         $groupby = ", ".strtolower($forumsort);
2392         $groupby = str_replace('desc', '', $groupby);
2393         $groupby = str_replace('asc', '', $groupby);
2394     }
2396     if (($limitfrom == 0 and $limitnum == 0) or $forumsort == "") {
2397         $sql = "SELECT p.discussion, COUNT(p.id) AS replies, MAX(p.id) AS lastpostid
2398                   FROM {forum_posts} p
2399                        JOIN {forum_discussions} d ON p.discussion = d.id
2400                  WHERE p.parent > 0 AND d.forum = ?
2401               GROUP BY p.discussion";
2402         return $DB->get_records_sql($sql, array($forumid));
2404     } else {
2405         $sql = "SELECT p.discussion, (COUNT(p.id) - 1) AS replies, MAX(p.id) AS lastpostid
2406                   FROM {forum_posts} p
2407                        JOIN {forum_discussions} d ON p.discussion = d.id
2408                  WHERE d.forum = ?
2409               GROUP BY p.discussion $groupby $orderby";
2410         return $DB->get_records_sql($sql, array($forumid), $limitfrom, $limitnum);
2411     }
2414 /**
2415  * @global object
2416  * @global object
2417  * @global object
2418  * @staticvar array $cache
2419  * @param object $forum
2420  * @param object $cm
2421  * @param object $course
2422  * @return mixed
2423  */
2424 function forum_count_discussions($forum, $cm, $course) {
2425     global $CFG, $DB, $USER;
2427     static $cache = array();
2429     $now = round(time(), -2); // db cache friendliness
2431     $params = array($course->id);
2433     if (!isset($cache[$course->id])) {
2434         if (!empty($CFG->forum_enabletimedposts)) {
2435             $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
2436             $params[] = $now;
2437             $params[] = $now;
2438         } else {
2439             $timedsql = "";
2440         }
2442         $sql = "SELECT f.id, COUNT(d.id) as dcount
2443                   FROM {forum} f
2444                        JOIN {forum_discussions} d ON d.forum = f.id
2445                  WHERE f.course = ?
2446                        $timedsql
2447               GROUP BY f.id";
2449         if ($counts = $DB->get_records_sql($sql, $params)) {
2450             foreach ($counts as $count) {
2451                 $counts[$count->id] = $count->dcount;
2452             }
2453             $cache[$course->id] = $counts;
2454         } else {
2455             $cache[$course->id] = array();
2456         }
2457     }
2459     if (empty($cache[$course->id][$forum->id])) {
2460         return 0;
2461     }
2463     $groupmode = groups_get_activity_groupmode($cm, $course);
2465     if ($groupmode != SEPARATEGROUPS) {
2466         return $cache[$course->id][$forum->id];
2467     }
2469     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
2470         return $cache[$course->id][$forum->id];
2471     }
2473     require_once($CFG->dirroot.'/course/lib.php');
2475     $modinfo = get_fast_modinfo($course);
2477     $mygroups = $modinfo->get_groups($cm->groupingid);
2479     // add all groups posts
2480     $mygroups[-1] = -1;
2482     list($mygroups_sql, $params) = $DB->get_in_or_equal($mygroups);
2483     $params[] = $forum->id;
2485     if (!empty($CFG->forum_enabletimedposts)) {
2486         $timedsql = "AND d.timestart < $now AND (d.timeend = 0 OR d.timeend > $now)";
2487         $params[] = $now;
2488         $params[] = $now;
2489     } else {
2490         $timedsql = "";
2491     }
2493     $sql = "SELECT COUNT(d.id)
2494               FROM {forum_discussions} d
2495              WHERE d.groupid $mygroups_sql AND d.forum = ?
2496                    $timedsql";
2498     return $DB->get_field_sql($sql, $params);
2501 /**
2502  * Get all discussions in a forum
2503  *
2504  * @global object
2505  * @global object
2506  * @global object
2507  * @uses CONTEXT_MODULE
2508  * @uses VISIBLEGROUPS
2509  * @param object $cm
2510  * @param string $forumsort
2511  * @param bool $fullpost
2512  * @param int $unused
2513  * @param int $limit
2514  * @param bool $userlastmodified
2515  * @param int $page
2516  * @param int $perpage
2517  * @param int $groupid if groups enabled, get discussions for this group overriding the current group.
2518  *                     Use FORUM_POSTS_ALL_USER_GROUPS for all the user groups
2519  * @return array
2520  */
2521 function forum_get_discussions($cm, $forumsort="", $fullpost=true, $unused=-1, $limit=-1,
2522                                 $userlastmodified=false, $page=-1, $perpage=0, $groupid = -1) {
2523     global $CFG, $DB, $USER;
2525     $timelimit = '';
2527     $now = round(time(), -2);
2528     $params = array($cm->instance);
2530     $modcontext = context_module::instance($cm->id);
2532     if (!has_capability('mod/forum:viewdiscussion', $modcontext)) { /// User must have perms to view discussions
2533         return array();
2534     }
2536     if (!empty($CFG->forum_enabletimedposts)) { /// Users must fulfill timed posts
2538         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2539             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2540             $params[] = $now;
2541             $params[] = $now;
2542             if (isloggedin()) {
2543                 $timelimit .= " OR d.userid = ?";
2544                 $params[] = $USER->id;
2545             }
2546             $timelimit .= ")";
2547         }
2548     }
2550     if ($limit > 0) {
2551         $limitfrom = 0;
2552         $limitnum  = $limit;
2553     } else if ($page != -1) {
2554         $limitfrom = $page*$perpage;
2555         $limitnum  = $perpage;
2556     } else {
2557         $limitfrom = 0;
2558         $limitnum  = 0;
2559     }
2561     $groupmode    = groups_get_activity_groupmode($cm);
2563     if ($groupmode) {
2565         if (empty($modcontext)) {
2566             $modcontext = context_module::instance($cm->id);
2567         }
2569         // Special case, we received a groupid to override currentgroup.
2570         if ($groupid > 0) {
2571             $course = get_course($cm->course);
2572             if (!groups_group_visible($groupid, $course, $cm)) {
2573                 // User doesn't belong to this group, return nothing.
2574                 return array();
2575             }
2576             $currentgroup = $groupid;
2577         } else if ($groupid === -1) {
2578             $currentgroup = groups_get_activity_group($cm);
2579         } else {
2580             // Get discussions for all groups current user can see.
2581             $currentgroup = null;
2582         }
2584         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2585             if ($currentgroup) {
2586                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2587                 $params[] = $currentgroup;
2588             } else {
2589                 $groupselect = "";
2590             }
2592         } else {
2593             // Separate groups.
2595             // Get discussions for all groups current user can see.
2596             if ($currentgroup === null) {
2597                 $mygroups = array_keys(groups_get_all_groups($cm->course, $USER->id, $cm->groupingid, 'g.id'));
2598                 if (empty($mygroups)) {
2599                      $groupselect = "AND d.groupid = -1";
2600                 } else {
2601                     list($insqlgroups, $inparamsgroups) = $DB->get_in_or_equal($mygroups);
2602                     $groupselect = "AND (d.groupid = -1 OR d.groupid $insqlgroups)";
2603                     $params = array_merge($params, $inparamsgroups);
2604                 }
2605             } else if ($currentgroup) {
2606                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2607                 $params[] = $currentgroup;
2608             } else {
2609                 $groupselect = "AND d.groupid = -1";
2610             }
2611         }
2612     } else {
2613         $groupselect = "";
2614     }
2615     if (empty($forumsort)) {
2616         $forumsort = forum_get_default_sort_order();
2617     }
2618     if (empty($fullpost)) {
2619         $postdata = "p.id,p.subject,p.modified,p.discussion,p.userid";
2620     } else {
2621         $postdata = "p.*";
2622     }
2624     if (empty($userlastmodified)) {  // We don't need to know this
2625         $umfields = "";
2626         $umtable  = "";
2627     } else {
2628         $umfields = ', ' . get_all_user_name_fields(true, 'um', null, 'um') . ', um.email AS umemail, um.picture AS umpicture,
2629                         um.imagealt AS umimagealt';
2630         $umtable  = " LEFT JOIN {user} um ON (d.usermodified = um.id)";
2631     }
2633     $allnames = get_all_user_name_fields(true, 'u');
2634     $sql = "SELECT $postdata, d.name, d.timemodified, d.usermodified, d.groupid, d.timestart, d.timeend, d.pinned, $allnames,
2635                    u.email, u.picture, u.imagealt $umfields
2636               FROM {forum_discussions} d
2637                    JOIN {forum_posts} p ON p.discussion = d.id
2638                    JOIN {user} u ON p.userid = u.id
2639                    $umtable
2640              WHERE d.forum = ? AND p.parent = 0
2641                    $timelimit $groupselect
2642           ORDER BY $forumsort, d.id DESC";
2643     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
2646 /**
2647  * Gets the neighbours (previous and next) of a discussion.
2648  *
2649  * The calculation is based on the timemodified when time modified or time created is identical
2650  * It will revert to using the ID to sort consistently. This is better tha skipping a discussion.
2651  *
2652  * For blog-style forums, the calculation is based on the original creation time of the
2653  * blog post.
2654  *
2655  * Please note that this does not check whether or not the discussion passed is accessible
2656  * by the user, it simply uses it as a reference to find the neighbours. On the other hand,
2657  * the returned neighbours are checked and are accessible to the current user.
2658  *
2659  * @param object $cm The CM record.
2660  * @param object $discussion The discussion record.
2661  * @param object $forum The forum instance record.
2662  * @return array That always contains the keys 'prev' and 'next'. When there is a result
2663  *               they contain the record with minimal information such as 'id' and 'name'.
2664  *               When the neighbour is not found the value is false.
2665  */
2666 function forum_get_discussion_neighbours($cm, $discussion, $forum) {
2667     global $CFG, $DB, $USER;
2669     if ($cm->instance != $discussion->forum or $discussion->forum != $forum->id or $forum->id != $cm->instance) {
2670         throw new coding_exception('Discussion is not part of the same forum.');
2671     }
2673     $neighbours = array('prev' => false, 'next' => false);
2674     $now = round(time(), -2);
2675     $params = array();
2677     $modcontext = context_module::instance($cm->id);
2678     $groupmode    = groups_get_activity_groupmode($cm);
2679     $currentgroup = groups_get_activity_group($cm);
2681     // Users must fulfill timed posts.
2682     $timelimit = '';
2683     if (!empty($CFG->forum_enabletimedposts)) {
2684         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2685             $timelimit = ' AND ((d.timestart <= :tltimestart AND (d.timeend = 0 OR d.timeend > :tltimeend))';
2686             $params['tltimestart'] = $now;
2687             $params['tltimeend'] = $now;
2688             if (isloggedin()) {
2689                 $timelimit .= ' OR d.userid = :tluserid';
2690                 $params['tluserid'] = $USER->id;
2691             }
2692             $timelimit .= ')';
2693         }
2694     }
2696     // Limiting to posts accessible according to groups.
2697     $groupselect = '';
2698     if ($groupmode) {
2699         if ($groupmode == VISIBLEGROUPS || has_capability('moodle/site:accessallgroups', $modcontext)) {
2700             if ($currentgroup) {
2701                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2702                 $params['groupid'] = $currentgroup;
2703             }
2704         } else {
2705             if ($currentgroup) {
2706                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2707                 $params['groupid'] = $currentgroup;
2708             } else {
2709                 $groupselect = 'AND d.groupid = -1';
2710             }
2711         }
2712     }
2714     $params['forumid'] = $cm->instance;
2715     $params['discid1'] = $discussion->id;
2716     $params['discid2'] = $discussion->id;
2717     $params['discid3'] = $discussion->id;
2718     $params['discid4'] = $discussion->id;
2719     $params['disctimecompare1'] = $discussion->timemodified;
2720     $params['disctimecompare2'] = $discussion->timemodified;
2721     $params['pinnedstate1'] = (int) $discussion->pinned;
2722     $params['pinnedstate2'] = (int) $discussion->pinned;
2723     $params['pinnedstate3'] = (int) $discussion->pinned;
2724     $params['pinnedstate4'] = (int) $discussion->pinned;
2726     $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
2727               FROM {forum_discussions} d
2728               JOIN {forum_posts} p ON d.firstpost = p.id
2729              WHERE d.forum = :forumid
2730                AND d.id <> :discid1
2731                    $timelimit
2732                    $groupselect";
2733     $comparefield = "d.timemodified";
2734     $comparevalue = ":disctimecompare1";
2735     $comparevalue2  = ":disctimecompare2";
2736     if (!empty($CFG->forum_enabletimedposts)) {
2737         // Here we need to take into account the release time (timestart)
2738         // if one is set, of the neighbouring posts and compare it to the
2739         // timestart or timemodified of *this* post depending on if the
2740         // release date of this post is in the future or not.
2741         // This stops discussions that appear later because of the
2742         // timestart value from being buried under discussions that were
2743         // made afterwards.
2744         $comparefield = "CASE WHEN d.timemodified < d.timestart
2745                                 THEN d.timestart ELSE d.timemodified END";
2746         if ($discussion->timemodified < $discussion->timestart) {
2747             // Normally we would just use the timemodified for sorting
2748             // discussion posts. However, when timed discussions are enabled,
2749             // then posts need to be sorted base on the later of timemodified
2750             // or the release date of the post (timestart).
2751             $params['disctimecompare1'] = $discussion->timestart;
2752             $params['disctimecompare2'] = $discussion->timestart;
2753         }
2754     }
2755     $orderbydesc = forum_get_default_sort_order(true, $comparefield, 'd', false);
2756     $orderbyasc = forum_get_default_sort_order(false, $comparefield, 'd', false);
2758     if ($forum->type === 'blog') {
2759          $subselect = "SELECT pp.created
2760                    FROM {forum_discussions} dd
2761                    JOIN {forum_posts} pp ON dd.firstpost = pp.id ";
2763          $subselectwhere1 = " WHERE dd.id = :discid3";
2764          $subselectwhere2 = " WHERE dd.id = :discid4";
2766          $comparefield = "p.created";
2768          $sub1 = $subselect.$subselectwhere1;
2769          $comparevalue = "($sub1)";
2771          $sub2 = $subselect.$subselectwhere2;
2772          $comparevalue2 = "($sub2)";
2774          $orderbydesc = "d.pinned, p.created DESC";
2775          $orderbyasc = "d.pinned, p.created ASC";
2776     }
2778     $prevsql = $sql . " AND ( (($comparefield < $comparevalue) AND :pinnedstate1 = d.pinned)
2779                          OR ($comparefield = $comparevalue2 AND (d.pinned = 0 OR d.pinned = :pinnedstate4) AND d.id < :discid2)
2780                          OR (d.pinned = 0 AND d.pinned <> :pinnedstate2))
2781                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbydesc, d.id DESC";
2783     $nextsql = $sql . " AND ( (($comparefield > $comparevalue) AND :pinnedstate1 = d.pinned)
2784                          OR ($comparefield = $comparevalue2 AND (d.pinned = 1 OR d.pinned = :pinnedstate4) AND d.id > :discid2)
2785                          OR (d.pinned = 1 AND d.pinned <> :pinnedstate2))
2786                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbyasc, d.id ASC";
2788     $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
2789     $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
2790     return $neighbours;
2793 /**
2794  * Get the sql to use in the ORDER BY clause for forum discussions.
2795  *
2796  * This has the ordering take timed discussion windows into account.
2797  *
2798  * @param bool $desc True for DESC, False for ASC.
2799  * @param string $compare The field in the SQL to compare to normally sort by.
2800  * @param string $prefix The prefix being used for the discussion table.
2801  * @param bool $pinned sort pinned posts to the top
2802  * @return string
2803  */
2804 function forum_get_default_sort_order($desc = true, $compare = 'd.timemodified', $prefix = 'd', $pinned = true) {
2805     global $CFG;
2807     if (!empty($prefix)) {
2808         $prefix .= '.';
2809     }
2811     $dir = $desc ? 'DESC' : 'ASC';
2813     if ($pinned == true) {
2814         $pinned = "{$prefix}pinned DESC,";
2815     } else {
2816         $pinned = '';
2817     }
2819     $sort = "{$prefix}timemodified";
2820     if (!empty($CFG->forum_enabletimedposts)) {
2821         $sort = "CASE WHEN {$compare} < {$prefix}timestart
2822                  THEN {$prefix}timestart
2823                  ELSE {$compare}
2824                  END";
2825     }
2826     return "$pinned $sort $dir";
2829 /**
2830  *
2831  * @global object
2832  * @global object
2833  * @global object
2834  * @uses CONTEXT_MODULE
2835  * @uses VISIBLEGROUPS
2836  * @param object $cm
2837  * @return array
2838  */
2839 function forum_get_discussions_unread($cm) {
2840     global $CFG, $DB, $USER;
2842     $now = round(time(), -2);
2843     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2845     $params = array();
2846     $groupmode    = groups_get_activity_groupmode($cm);
2847     $currentgroup = groups_get_activity_group($cm);
2849     if ($groupmode) {
2850         $modcontext = context_module::instance($cm->id);
2852         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2853             if ($currentgroup) {
2854                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2855                 $params['currentgroup'] = $currentgroup;
2856             } else {
2857                 $groupselect = "";
2858             }
2860         } else {
2861             //separate groups without access all
2862             if ($currentgroup) {
2863                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2864                 $params['currentgroup'] = $currentgroup;
2865             } else {
2866                 $groupselect = "AND d.groupid = -1";
2867             }
2868         }
2869     } else {
2870         $groupselect = "";
2871     }
2873     if (!empty($CFG->forum_enabletimedposts)) {
2874         $timedsql = "AND d.timestart < :now1 AND (d.timeend = 0 OR d.timeend > :now2)";
2875         $params['now1'] = $now;
2876         $params['now2'] = $now;
2877     } else {
2878         $timedsql = "";
2879     }
2881     $sql = "SELECT d.id, COUNT(p.id) AS unread
2882               FROM {forum_discussions} d
2883                    JOIN {forum_posts} p     ON p.discussion = d.id
2884                    LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = $USER->id)
2885              WHERE d.forum = {$cm->instance}
2886                    AND p.modified >= :cutoffdate AND r.id is NULL
2887                    $groupselect
2888                    $timedsql
2889           GROUP BY d.id";
2890     $params['cutoffdate'] = $cutoffdate;
2892     if ($unreads = $DB->get_records_sql($sql, $params)) {
2893         foreach ($unreads as $unread) {
2894             $unreads[$unread->id] = $unread->unread;
2895         }
2896         return $unreads;
2897     } else {
2898         return array();
2899     }
2902 /**
2903  * @global object
2904  * @global object
2905  * @global object
2906  * @uses CONEXT_MODULE
2907  * @uses VISIBLEGROUPS
2908  * @param object $cm
2909  * @return array
2910  */
2911 function forum_get_discussions_count($cm) {
2912     global $CFG, $DB, $USER;
2914     $now = round(time(), -2);
2915     $params = array($cm->instance);
2916     $groupmode    = groups_get_activity_groupmode($cm);
2917     $currentgroup = groups_get_activity_group($cm);
2919     if ($groupmode) {
2920         $modcontext = context_module::instance($cm->id);
2922         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2923             if ($currentgroup) {
2924                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2925                 $params[] = $currentgroup;
2926             } else {
2927                 $groupselect = "";
2928             }
2930         } else {
2931             //seprate groups without access all
2932             if ($currentgroup) {
2933                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2934                 $params[] = $currentgroup;
2935             } else {
2936                 $groupselect = "AND d.groupid = -1";
2937             }
2938         }
2939     } else {
2940         $groupselect = "";
2941     }
2943     $timelimit = "";
2945     if (!empty($CFG->forum_enabletimedposts)) {
2947         $modcontext = context_module::instance($cm->id);
2949         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2950             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2951             $params[] = $now;
2952             $params[] = $now;
2953             if (isloggedin()) {
2954                 $timelimit .= " OR d.userid = ?";
2955                 $params[] = $USER->id;
2956             }
2957             $timelimit .= ")";
2958         }
2959     }
2961     $sql = "SELECT COUNT(d.id)
2962               FROM {forum_discussions} d
2963                    JOIN {forum_posts} p ON p.discussion = d.id
2964              WHERE d.forum = ? AND p.parent = 0
2965                    $groupselect $timelimit";
2967     return $DB->get_field_sql($sql, $params);
2971 // OTHER FUNCTIONS ///////////////////////////////////////////////////////////
2974 /**
2975  * @global object
2976  * @global object
2977  * @param int $courseid
2978  * @param string $type
2979  */
2980 function forum_get_course_forum($courseid, $type) {
2981 // How to set up special 1-per-course forums
2982     global $CFG, $DB, $OUTPUT, $USER;
2984     if ($forums = $DB->get_records_select("forum", "course = ? AND type = ?", array($courseid, $type), "id ASC")) {
2985         // There should always only be ONE, but with the right combination of
2986         // errors there might be more.  In this case, just return the oldest one (lowest ID).
2987         foreach ($forums as $forum) {
2988             return $forum;   // ie the first one
2989         }
2990     }
2992     // Doesn't exist, so create one now.
2993     $forum = new stdClass();
2994     $forum->course = $courseid;
2995     $forum->type = "$type";
2996     if (!empty($USER->htmleditor)) {
2997         $forum->introformat = $USER->htmleditor;
2998     }
2999     switch ($forum->type) {
3000         case "news":
3001             $forum->name  = get_string("namenews", "forum");
3002             $forum->intro = get_string("intronews", "forum");
3003             $forum->forcesubscribe = FORUM_FORCESUBSCRIBE;
3004             $forum->assessed = 0;
3005             if ($courseid == SITEID) {
3006                 $forum->name  = get_string("sitenews");
3007                 $forum->forcesubscribe = 0;
3008             }
3009             break;
3010         case "social":
3011             $forum->name  = get_string("namesocial", "forum");
3012             $forum->intro = get_string("introsocial", "forum");
3013             $forum->assessed = 0;
3014             $forum->forcesubscribe = 0;
3015             break;
3016         case "blog":
3017             $forum->name = get_string('blogforum', 'forum');
3018             $forum->intro = get_string('introblog', 'forum');
3019             $forum->assessed = 0;
3020             $forum->forcesubscribe = 0;
3021             break;
3022         default:
3023             echo $OUTPUT->notification("That forum type doesn't exist!");
3024             return false;
3025             break;
3026     }
3028     $forum->timemodified = time();
3029     $forum->id = $DB->insert_record("forum", $forum);
3031     if (! $module = $DB->get_record("modules", array("name" => "forum"))) {
3032         echo $OUTPUT->notification("Could not find forum module!!");
3033         return false;
3034     }
3035     $mod = new stdClass();
3036     $mod->course = $courseid;
3037     $mod->module = $module->id;
3038     $mod->instance = $forum->id;
3039     $mod->section = 0;
3040     include_once("$CFG->dirroot/course/lib.php");
3041     if (! $mod->coursemodule = add_course_module($mod) ) {
3042         echo $OUTPUT->notification("Could not add a new course module to the course '" . $courseid . "'");
3043         return false;
3044     }
3045     $sectionid = course_add_cm_to_section($courseid, $mod->coursemodule, 0);
3046     return $DB->get_record("forum", array("id" => "$forum->id"));
3049 /**
3050  * Print a forum post
3051  *
3052  * @global object
3053  * @global object
3054  * @uses FORUM_MODE_THREADED
3055  * @uses PORTFOLIO_FORMAT_PLAINHTML
3056  * @uses PORTFOLIO_FORMAT_FILE
3057  * @uses PORTFOLIO_FORMAT_RICHHTML
3058  * @uses PORTFOLIO_ADD_TEXT_LINK
3059  * @uses CONTEXT_MODULE
3060  * @param object $post The post to print.
3061  * @param object $discussion
3062  * @param object $forum
3063  * @param object $cm
3064  * @param object $course
3065  * @param boolean $ownpost Whether this post belongs to the current user.
3066  * @param boolean $reply Whether to print a 'reply' link at the bottom of the message.
3067  * @param boolean $link Just print a shortened version of the post as a link to the full post.
3068  * @param string $footer Extra stuff to print after the message.
3069  * @param string $highlight Space-separated list of terms to highlight.
3070  * @param int $post_read true, false or -99. If we already know whether this user
3071  *          has read this post, pass that in, otherwise, pass in -99, and this
3072  *          function will work it out.
3073  * @param boolean $dummyifcantsee When forum_user_can_see_post says that
3074  *          the current user can't see this post, if this argument is true
3075  *          (the default) then print a dummy 'you can't see this post' post.
3076  *          If false, don't output anything at all.
3077  * @param bool|null $istracked
3078  * @return void
3079  */
3080 function forum_print_post($post, $discussion, $forum, &$cm, $course, $ownpost=false, $reply=false, $link=false,
3081                           $footer="", $highlight="", $postisread=null, $dummyifcantsee=true, $istracked=null, $return=false) {
3082     global $USER, $CFG, $OUTPUT;
3084     require_once($CFG->libdir . '/filelib.php');
3086     // String cache
3087     static $str;
3088     // This is an extremely hacky way to ensure we only print the 'unread' anchor
3089     // the first time we encounter an unread post on a page. Ideally this would
3090     // be moved into the caller somehow, and be better testable. But at the time
3091     // of dealing with this bug, this static workaround was the most surgical and
3092     // it fits together with only printing th unread anchor id once on a given page.
3093     static $firstunreadanchorprinted = false;
3095     $modcontext = context_module::instance($cm->id);
3097     $post->course = $course->id;
3098     $post->forum  = $forum->id;
3099     $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
3100     if (!empty($CFG->enableplagiarism)) {
3101         require_once($CFG->libdir.'/plagiarismlib.php');
3102         $post->message .= plagiarism_get_links(array('userid' => $post->userid,
3103             'content' => $post->message,
3104             'cmid' => $cm->id,
3105             'course' => $post->course,
3106             'forum' => $post->forum));
3107     }
3109     // caching
3110     if (!isset($cm->cache)) {
3111         $cm->cache = new stdClass;
3112     }
3114     if (!isset($cm->cache->caps)) {
3115         $cm->cache->caps = array();
3116         $cm->cache->caps['mod/forum:viewdiscussion']   = has_capability('mod/forum:viewdiscussion', $modcontext);
3117         $cm->cache->caps['moodle/site:viewfullnames']  = has_capability('moodle/site:viewfullnames', $modcontext);
3118         $cm->cache->caps['mod/forum:editanypost']      = has_capability('mod/forum:editanypost', $modcontext);
3119         $cm->cache->caps['mod/forum:splitdiscussions'] = has_capability('mod/forum:splitdiscussions', $modcontext);
3120         $cm->cache->caps['mod/forum:deleteownpost']    = has_capability('mod/forum:deleteownpost', $modcontext);
3121         $cm->cache->caps['mod/forum:deleteanypost']    = has_capability('mod/forum:deleteanypost', $modcontext);
3122         $cm->cache->caps['mod/forum:viewanyrating']    = has_capability('mod/forum:viewanyrating', $modcontext);
3123         $cm->cache->caps['mod/forum:exportpost']       = has_capability('mod/forum:exportpost', $modcontext);
3124         $cm->cache->caps['mod/forum:exportownpost']    = has_capability('mod/forum:exportownpost', $modcontext);
3125     }
3127     if (!isset($cm->uservisible)) {
3128         $cm->uservisible = \core_availability\info_module::is_user_visible($cm, 0, false);
3129     }
3131     if ($istracked && is_null($postisread)) {
3132         $postisread = forum_tp_is_post_read($USER->id, $post);
3133     }
3135     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
3136         $output = '';
3137         if (!$dummyifcantsee) {
3138             if ($return) {
3139                 return $output;
3140             }
3141             echo $output;
3142             return;
3143         }
3144         $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3145         $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix',
3146                                                        'role' => 'region',
3147                                                        'aria-label' => get_string('hiddenforumpost', 'forum')));
3148         $output .= html_writer::start_tag('div', array('class'=>'row header'));
3149         $output .= html_writer::tag('div', '', array('class'=>'left picture')); // Picture
3150         if ($post->parent) {
3151             $output .= html_writer::start_tag('div', array('class'=>'topic'));
3152         } else {
3153             $output .= html_writer::start_tag('div', array('class'=>'topic starter'));
3154         }
3155         $output .= html_writer::tag('div', get_string('forumsubjecthidden','forum'), array('class' => 'subject',
3156                                                                                            'role' => 'header')); // Subject.
3157         $output .= html_writer::tag('div', get_string('forumauthorhidden', 'forum'), array('class' => 'author',
3158                                                                                            'role' => 'header')); // Author.
3159         $output .= html_writer::end_tag('div');
3160         $output .= html_writer::end_tag('div'); // row
3161         $output .= html_writer::start_tag('div', array('class'=>'row'));
3162         $output .= html_writer::tag('div', '&nbsp;', array('class'=>'left side')); // Groups
3163         $output .= html_writer::tag('div', get_string('forumbodyhidden','forum'), array('class'=>'content')); // Content
3164         $output .= html_writer::end_tag('div'); // row
3165         $output .= html_writer::end_tag('div'); // forumpost
3167         if ($return) {
3168             return $output;
3169         }
3170         echo $output;
3171         return;
3172     }
3174     if (empty($str)) {
3175         $str = new stdClass;
3176         $str->edit         = get_string('edit', 'forum');
3177         $str->delete       = get_string('delete', 'forum');
3178         $str->reply        = get_string('reply', 'forum');
3179         $str->parent       = get_string('parent', 'forum');
3180         $str->pruneheading = get_string('pruneheading', 'forum');
3181         $str->prune        = get_string('prune', 'forum');
3182         $str->displaymode     = get_user_preferences('forum_displaymode', $CFG->forum_displaymode);
3183         $str->markread     = get_string('markread', 'forum');
3184         $str->markunread   = get_string('markunread', 'forum');
3185     }
3187     $discussionlink = new moodle_url('/mod/forum/discuss.php', array('d'=>$post->discussion));
3189     // Build an object that represents the posting user
3190     $postuser = new stdClass;
3191     $postuserfields = explode(',', user_picture::fields());
3192     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
3193     $postuser->id = $post->userid;
3194     $postuser->fullname    = fullname($postuser, $cm->cache->caps['moodle/site:viewfullnames']);
3195     $postuser->profilelink = new moodle_url('/user/view.php', array('id'=>$post->userid, 'course'=>$course->id));
3197     // Prepare the groups the posting user belongs to
3198     if (isset($cm->cache->usersgroups)) {
3199         $groups = array();
3200         if (isset($cm->cache->usersgroups[$post->userid])) {
3201             foreach ($cm->cache->usersgroups[$post->userid] as $gid) {
3202                 $groups[$gid] = $cm->cache->groups[$gid];
3203             }
3204         }
3205     } else {
3206         $groups = groups_get_all_groups($course->id, $post->userid, $cm->groupingid);
3207     }
3209     // Prepare the attachements for the post, files then images
3210     list($attachments, $attachedimages) = forum_print_attachments($post, $cm, 'separateimages');
3212     // Determine if we need to shorten this post
3213     $shortenpost = ($link && (strlen(strip_tags($post->message)) > $CFG->forum_longpost));
3216     // Prepare an array of commands
3217     $commands = array();
3219     // Add a permalink.
3220     $permalink = new moodle_url($discussionlink);
3221     $permalink->set_anchor('p' . $post->id);
3222     $commands[] = array('url' => $permalink, 'text' => get_string('permalink', 'forum'));
3224     // SPECIAL CASE: The front page can display a news item post to non-logged in users.
3225     // Don't display the mark read / unread controls in this case.
3226     if ($istracked && $CFG->forum_usermarksread && isloggedin()) {
3227         $url = new moodle_url($discussionlink, array('postid'=>$post->id, 'mark'=>'unread'));
3228         $text = $str->markunread;
3229         if (!$postisread) {
3230             $url->param('mark', 'read');
3231             $text = $str->markread;
3232         }
3233         if ($str->displaymode == FORUM_MODE_THREADED) {
3234             $url->param('parent', $post->parent);
3235         } else {
3236             $url->set_anchor('p'.$post->id);
3237         }
3238         $commands[] = array('url'=>$url, 'text'=>$text);
3239     }
3241     // Zoom in to the parent specifically
3242     if ($post->parent) {
3243         $url = new moodle_url($discussionlink);
3244         if ($str->displaymode == FORUM_MODE_THREADED) {
3245             $url->param('parent', $post->parent);
3246         } else {
3247             $url->set_anchor('p'.$post->parent);
3248         }
3249         $commands[] = array('url'=>$url, 'text'=>$str->parent);
3250     }
3252     // Hack for allow to edit news posts those are not displayed yet until they are displayed
3253     $age = time() - $post->created;
3254     if (!$post->parent && $forum->type == 'news' && $discussion->timestart > time()) {
3255         $age = 0;
3256     }
3258     if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3259         if (has_capability('moodle/course:manageactivities', $modcontext)) {
3260             // The first post in single simple is the forum description.
3261             $commands[] = array('url'=>new moodle_url('/course/modedit.php', array('update'=>$cm->id, 'sesskey'=>sesskey(), 'return'=>1)), 'text'=>$str->edit);
3262         }
3263     } else if (($ownpost && $age < $CFG->maxeditingtime) || $cm->cache->caps['mod/forum:editanypost']) {
3264         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('edit'=>$post->id)), 'text'=>$str->edit);
3265     }
3267     if ($cm->cache->caps['mod/forum:splitdiscussions'] && $post->parent && $forum->type != 'single') {
3268         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('prune'=>$post->id)), 'text'=>$str->prune, 'title'=>$str->pruneheading);
3269     }
3271     if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3272         // Do not allow deleting of first post in single simple type.
3273     } else if (($ownpost && $age < $CFG->maxeditingtime && $cm->cache->caps['mod/forum:deleteownpost']) || $cm->cache->caps['mod/forum:deleteanypost']) {
3274         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('delete'=>$post->id)), 'text'=>$str->delete);
3275     }
3277     if ($reply) {
3278         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php#mformforum', array('reply'=>$post->id)), 'text'=>$str->reply);
3279     }
3281     if ($CFG->enableportfolios && ($cm->cache->caps['mod/forum:exportpost'] || ($ownpost && $cm->cache->caps['mod/forum:exportownpost']))) {
3282         $p = array('postid' => $post->id);
3283         require_once($CFG->libdir.'/portfoliolib.php');
3284         $button = new portfolio_add_button();
3285         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id), 'mod_forum');
3286         if (empty($attachments)) {
3287             $button->set_formats(PORTFOLIO_FORMAT_PLAINHTML);
3288         } else {
3289             $button->set_formats(PORTFOLIO_FORMAT_RICHHTML);
3290         }
3292         $porfoliohtml = $button->to_html(PORTFOLIO_ADD_TEXT_LINK);
3293         if (!empty($porfoliohtml)) {
3294             $commands[] = $porfoliohtml;
3295         }
3296     }
3297     // Finished building commands
3300     // Begin output
3302     $output  = '';
3304     if ($istracked) {
3305         if ($postisread) {
3306             $forumpostclass = ' read';
3307         } else {
3308             $forumpostclass = ' unread';
3309             // If this is the first unread post printed then give it an anchor and id of unread.
3310             if (!$firstunreadanchorprinted) {
3311                 $output .= html_writer::tag('a', '', array('id' => 'unread'));
3312                 $firstunreadanchorprinted = true;
3313             }
3314         }
3315     } else {
3316         // ignore trackign status if not tracked or tracked param missing
3317         $forumpostclass = '';
3318     }
3320     $topicclass = '';
3321     if (empty($post->parent)) {
3322         $topicclass = ' firstpost starter';
3323     }
3325     if (!empty($post->lastpost)) {
3326         $forumpostclass .= ' lastpost';
3327     }
3329     // Flag to indicate whether we should hide the author or not.
3330     $authorhidden = forum_is_author_hidden($post, $forum);
3331     $postbyuser = new stdClass;
3332     $postbyuser->post = $post->subject;
3333     $postbyuser->user = $postuser->fullname;
3334     $discussionbyuser = get_string('postbyuser', 'forum', $postbyuser);
3335     $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3336     // Begin forum post.
3337     $output .= html_writer::start_div('forumpost clearfix' . $forumpostclass . $topicclass,
3338         ['role' => 'region', 'aria-label' => $discussionbyuser]);
3339     // Begin header row.
3340     $output .= html_writer::start_div('row header clearfix');
3342     // User picture.
3343     if (!$authorhidden) {
3344         $picture = $OUTPUT->user_picture($postuser, ['courseid' => $course->id]);
3345         $output .= html_writer::div($picture, 'left picture');
3346         $topicclass = 'topic' . $topicclass;
3347     }
3349     // Begin topic column.
3350     $output .= html_writer::start_div($topicclass);
3351     $postsubject = $post->subject;
3352     if (empty($post->subjectnoformat)) {
3353         $postsubject = format_string($postsubject);
3354     }
3355     $output .= html_writer::div($postsubject, 'subject', ['role' => 'heading', 'aria-level' => '2']);
3357     if ($authorhidden) {
3358         $bytext = userdate($post->modified);
3359     } else {
3360         $by = new stdClass();
3361         $by->date = userdate($post->modified);
3362         $by->name = html_writer::link($postuser->profilelink, $postuser->fullname);
3363         $bytext = get_string('bynameondate', 'forum', $by);
3364     }
3365     $bytextoptions = [
3366         'role' => 'heading',
3367         'aria-level' => '2',
3368     ];
3369     $output .= html_writer::div($bytext, 'author', $bytextoptions);
3370     // End topic column.
3371     $output .= html_writer::end_div();
3373     // End header row.
3374     $output .= html_writer::end_div();
3376     // Row with the forum post content.
3377     $output .= html_writer::start_div('row maincontent clearfix');
3378     // Show if author is not hidden or we have groups.
3379     if (!$authorhidden || $groups) {
3380         $output .= html_writer::start_div('left');
3381         $groupoutput = '';
3382         if ($groups) {
3383             $groupoutput = print_group_picture($groups, $course->id, false, true, true);
3384         }
3385         if (empty($groupoutput)) {
3386             $groupoutput = '&nbsp;';
3387         }
3388         $output .= html_writer::div($groupoutput, 'grouppictures');
3389         $output .= html_writer::end_div(); // Left side.
3390     }
3392     $output .= html_writer::start_tag('div', array('class'=>'no-overflow'));
3393     $output .= html_writer::start_tag('div', array('class'=>'content'));
3395     $options = new stdClass;
3396     $options->para    = false;
3397     $options->trusted = $post->messagetrust;
3398     $options->context = $modcontext;
3399     if ($shortenpost) {
3400         // Prepare shortened version by filtering the text then shortening it.
3401         $postclass    = 'shortenedpost';
3402         $postcontent  = format_text($post->message, $post->messageformat, $options);
3403         $postcontent  = shorten_text($postcontent, $CFG->forum_shortpost);
3404         $postcontent .= html_writer::link($discussionlink, get_string('readtherest', 'forum'));
3405         $postcontent .= html_writer::tag('div', '('.get_string('numwords', 'moodle', count_words($post->message)).')',
3406             array('class'=>'post-word-count'));
3407     } else {
3408         // Prepare whole post
3409         $postclass    = 'fullpost';
3410         $postcontent  = format_text($post->message, $post->messageformat, $options, $course->id);
3411         if (!empty($highlight)) {
3412             $postcontent = highlight($highlight, $postcontent);
3413         }
3414         if (!empty($forum->displaywordcount)) {
3415             $postcontent .= html_writer::tag('div', get_string('numwords', 'moodle', count_words($post->message)),
3416                 array('class'=>'post-word-count'));
3417         }
3418         $postcontent .= html_writer::tag('div', $attachedimages, array('class'=>'attachedimages'));
3419     }
3421     // Output the post content
3422     $output .= html_writer::tag('div', $postcontent, array('class'=>'posting '.$postclass));
3423     $output .= html_writer::end_tag('div'); // Content
3424     $output .= html_writer::end_tag('div'); // Content mask
3425     $output .= html_writer::end_tag('div'); // Row
3427     $output .= html_writer::start_tag('div', array('class'=>'row side'));
3428     $output .= html_writer::tag('div','&nbsp;', array('class'=>'left'));
3429     $output .= html_writer::start_tag('div', array('class'=>'options clearfix'));
3431     if (!empty($attachments)) {
3432         $output .= html_writer::tag('div', $attachments, array('class' => 'attachments'));
3433     }
3435     // Output ratings
3436     if (!empty($post->rating)) {
3437         $output .= html_writer::tag('div', $OUTPUT->render($post->rating), array('class'=>'forum-post-rating'));
3438     }
3440     // Output the commands
3441     $commandhtml = array();
3442     foreach ($comman