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