MDL-3714 mod_forum: Add an inbound message handler
[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 /// STANDARD FUNCTIONS ///////////////////////////////////////////////////////////
69 /**
70  * Given an object containing all the necessary data,
71  * (defined by the form in mod_form.php) this function
72  * will create a new instance and return the id number
73  * of the new instance.
74  *
75  * @param stdClass $forum add forum instance
76  * @param mod_forum_mod_form $mform
77  * @return int intance id
78  */
79 function forum_add_instance($forum, $mform = null) {
80     global $CFG, $DB;
82     $forum->timemodified = time();
84     if (empty($forum->assessed)) {
85         $forum->assessed = 0;
86     }
88     if (empty($forum->ratingtime) or empty($forum->assessed)) {
89         $forum->assesstimestart  = 0;
90         $forum->assesstimefinish = 0;
91     }
93     $forum->id = $DB->insert_record('forum', $forum);
94     $modcontext = context_module::instance($forum->coursemodule);
96     if ($forum->type == 'single') {  // Create related discussion.
97         $discussion = new stdClass();
98         $discussion->course        = $forum->course;
99         $discussion->forum         = $forum->id;
100         $discussion->name          = $forum->name;
101         $discussion->assessed      = $forum->assessed;
102         $discussion->message       = $forum->intro;
103         $discussion->messageformat = $forum->introformat;
104         $discussion->messagetrust  = trusttext_trusted(context_course::instance($forum->course));
105         $discussion->mailnow       = false;
106         $discussion->groupid       = -1;
108         $message = '';
110         $discussion->id = forum_add_discussion($discussion, null, $message);
112         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
113             // Ugly hack - we need to copy the files somehow.
114             $discussion = $DB->get_record('forum_discussions', array('id'=>$discussion->id), '*', MUST_EXIST);
115             $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
117             $options = array('subdirs'=>true); // Use the same options as intro field!
118             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
119             $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
120         }
121     }
123     forum_grade_item_update($forum);
125     return $forum->id;
128 /**
129  * Handle changes following the creation of a forum instance.
130  * This function is typically called by the course_module_created observer.
131  *
132  * @param object $context the forum context
133  * @param stdClass $forum The forum object
134  * @return void
135  */
136 function forum_instance_created($context, $forum) {
137     if ($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) {
138         $users = \mod_forum\subscriptions::get_potential_subscribers($context, 0, 'u.id, u.email');
139         foreach ($users as $user) {
140             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $context);
141         }
142     }
145 /**
146  * Given an object containing all the necessary data,
147  * (defined by the form in mod_form.php) this function
148  * will update an existing instance with new data.
149  *
150  * @global object
151  * @param object $forum forum instance (with magic quotes)
152  * @return bool success
153  */
154 function forum_update_instance($forum, $mform) {
155     global $DB, $OUTPUT, $USER;
157     $forum->timemodified = time();
158     $forum->id           = $forum->instance;
160     if (empty($forum->assessed)) {
161         $forum->assessed = 0;
162     }
164     if (empty($forum->ratingtime) or empty($forum->assessed)) {
165         $forum->assesstimestart  = 0;
166         $forum->assesstimefinish = 0;
167     }
169     $oldforum = $DB->get_record('forum', array('id'=>$forum->id));
171     // MDL-3942 - if the aggregation type or scale (i.e. max grade) changes then recalculate the grades for the entire forum
172     // if  scale changes - do we need to recheck the ratings, if ratings higher than scale how do we want to respond?
173     // 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
174     if (($oldforum->assessed<>$forum->assessed) or ($oldforum->scale<>$forum->scale)) {
175         forum_update_grades($forum); // recalculate grades for the forum
176     }
178     if ($forum->type == 'single') {  // Update related discussion and post.
179         $discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id), 'timemodified ASC');
180         if (!empty($discussions)) {
181             if (count($discussions) > 1) {
182                 echo $OUTPUT->notification(get_string('warnformorepost', 'forum'));
183             }
184             $discussion = array_pop($discussions);
185         } else {
186             // try to recover by creating initial discussion - MDL-16262
187             $discussion = new stdClass();
188             $discussion->course          = $forum->course;
189             $discussion->forum           = $forum->id;
190             $discussion->name            = $forum->name;
191             $discussion->assessed        = $forum->assessed;
192             $discussion->message         = $forum->intro;
193             $discussion->messageformat   = $forum->introformat;
194             $discussion->messagetrust    = true;
195             $discussion->mailnow         = false;
196             $discussion->groupid         = -1;
198             $message = '';
200             forum_add_discussion($discussion, null, $message);
202             if (! $discussion = $DB->get_record('forum_discussions', array('forum'=>$forum->id))) {
203                 print_error('cannotadd', 'forum');
204             }
205         }
206         if (! $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost))) {
207             print_error('cannotfindfirstpost', 'forum');
208         }
210         $cm         = get_coursemodule_from_instance('forum', $forum->id);
211         $modcontext = context_module::instance($cm->id, MUST_EXIST);
213         $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
214         $post->subject       = $forum->name;
215         $post->message       = $forum->intro;
216         $post->messageformat = $forum->introformat;
217         $post->messagetrust  = trusttext_trusted($modcontext);
218         $post->modified      = $forum->timemodified;
219         $post->userid        = $USER->id;    // MDL-18599, so that current teacher can take ownership of activities.
221         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
222             // Ugly hack - we need to copy the files somehow.
223             $options = array('subdirs'=>true); // Use the same options as intro field!
224             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
225         }
227         $DB->update_record('forum_posts', $post);
228         $discussion->name = $forum->name;
229         $DB->update_record('forum_discussions', $discussion);
230     }
232     $DB->update_record('forum', $forum);
234     $modcontext = context_module::instance($forum->coursemodule);
235     if (($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) && ($oldforum->forcesubscribe <> $forum->forcesubscribe)) {
236         $users = \mod_forum\subscriptions::get_potential_subscribers($modcontext, 0, 'u.id, u.email', '');
237         foreach ($users as $user) {
238             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $modcontext);
239         }
240     }
242     forum_grade_item_update($forum);
244     return true;
248 /**
249  * Given an ID of an instance of this module,
250  * this function will permanently delete the instance
251  * and any data that depends on it.
252  *
253  * @global object
254  * @param int $id forum instance id
255  * @return bool success
256  */
257 function forum_delete_instance($id) {
258     global $DB;
260     if (!$forum = $DB->get_record('forum', array('id'=>$id))) {
261         return false;
262     }
263     if (!$cm = get_coursemodule_from_instance('forum', $forum->id)) {
264         return false;
265     }
266     if (!$course = $DB->get_record('course', array('id'=>$cm->course))) {
267         return false;
268     }
270     $context = context_module::instance($cm->id);
272     // now get rid of all files
273     $fs = get_file_storage();
274     $fs->delete_area_files($context->id);
276     $result = true;
278     // Delete digest and subscription preferences.
279     $DB->delete_records('forum_digests', array('forum' => $forum->id));
280     $DB->delete_records('forum_subscriptions', array('forum'=>$forum->id));
281     $DB->delete_records('forum_discussion_subs', array('forum' => $forum->id));
283     if ($discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id))) {
284         foreach ($discussions as $discussion) {
285             if (!forum_delete_discussion($discussion, true, $course, $cm, $forum)) {
286                 $result = false;
287             }
288         }
289     }
291     forum_tp_delete_read_records(-1, -1, -1, $forum->id);
293     if (!$DB->delete_records('forum', array('id'=>$forum->id))) {
294         $result = false;
295     }
297     forum_grade_item_delete($forum);
299     return $result;
303 /**
304  * Indicates API features that the forum supports.
305  *
306  * @uses FEATURE_GROUPS
307  * @uses FEATURE_GROUPINGS
308  * @uses FEATURE_MOD_INTRO
309  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
310  * @uses FEATURE_COMPLETION_HAS_RULES
311  * @uses FEATURE_GRADE_HAS_GRADE
312  * @uses FEATURE_GRADE_OUTCOMES
313  * @param string $feature
314  * @return mixed True if yes (some features may use other values)
315  */
316 function forum_supports($feature) {
317     switch($feature) {
318         case FEATURE_GROUPS:                  return true;
319         case FEATURE_GROUPINGS:               return true;
320         case FEATURE_MOD_INTRO:               return true;
321         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
322         case FEATURE_COMPLETION_HAS_RULES:    return true;
323         case FEATURE_GRADE_HAS_GRADE:         return true;
324         case FEATURE_GRADE_OUTCOMES:          return true;
325         case FEATURE_RATE:                    return true;
326         case FEATURE_BACKUP_MOODLE2:          return true;
327         case FEATURE_SHOW_DESCRIPTION:        return true;
328         case FEATURE_PLAGIARISM:              return true;
330         default: return null;
331     }
335 /**
336  * Obtains the automatic completion state for this forum based on any conditions
337  * in forum settings.
338  *
339  * @global object
340  * @global object
341  * @param object $course Course
342  * @param object $cm Course-module
343  * @param int $userid User ID
344  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
345  * @return bool True if completed, false if not. (If no conditions, then return
346  *   value depends on comparison type)
347  */
348 function forum_get_completion_state($course,$cm,$userid,$type) {
349     global $CFG,$DB;
351     // Get forum details
352     if (!($forum=$DB->get_record('forum',array('id'=>$cm->instance)))) {
353         throw new Exception("Can't find forum {$cm->instance}");
354     }
356     $result=$type; // Default return value
358     $postcountparams=array('userid'=>$userid,'forumid'=>$forum->id);
359     $postcountsql="
360 SELECT
361     COUNT(1)
362 FROM
363     {forum_posts} fp
364     INNER JOIN {forum_discussions} fd ON fp.discussion=fd.id
365 WHERE
366     fp.userid=:userid AND fd.forum=:forumid";
368     if ($forum->completiondiscussions) {
369         $value = $forum->completiondiscussions <=
370                  $DB->count_records('forum_discussions',array('forum'=>$forum->id,'userid'=>$userid));
371         if ($type == COMPLETION_AND) {
372             $result = $result && $value;
373         } else {
374             $result = $result || $value;
375         }
376     }
377     if ($forum->completionreplies) {
378         $value = $forum->completionreplies <=
379                  $DB->get_field_sql( $postcountsql.' AND fp.parent<>0',$postcountparams);
380         if ($type==COMPLETION_AND) {
381             $result = $result && $value;
382         } else {
383             $result = $result || $value;
384         }
385     }
386     if ($forum->completionposts) {
387         $value = $forum->completionposts <= $DB->get_field_sql($postcountsql,$postcountparams);
388         if ($type == COMPLETION_AND) {
389             $result = $result && $value;
390         } else {
391             $result = $result || $value;
392         }
393     }
395     return $result;
398 /**
399  * Create a message-id string to use in the custom headers of forum notification emails
400  *
401  * message-id is used by email clients to identify emails and to nest conversations
402  *
403  * @param int $postid The ID of the forum post we are notifying the user about
404  * @param int $usertoid The ID of the user being notified
405  * @param string $hostname The server's hostname
406  * @return string A unique message-id
407  */
408 function forum_get_email_message_id($postid, $usertoid, $hostname) {
409     return '<'.hash('sha256',$postid.'to'.$usertoid).'@'.$hostname.'>';
412 /**
413  * Removes properties from user record that are not necessary
414  * for sending post notifications.
415  * @param stdClass $user
416  * @return void, $user parameter is modified
417  */
418 function forum_cron_minimise_user_record(stdClass $user) {
420     // We store large amount of users in one huge array,
421     // make sure we do not store info there we do not actually need
422     // in mail generation code or messaging.
424     unset($user->institution);
425     unset($user->department);
426     unset($user->address);
427     unset($user->city);
428     unset($user->url);
429     unset($user->currentlogin);
430     unset($user->description);
431     unset($user->descriptionformat);
434 /**
435  * Function to be run periodically according to the scheduled task.
436  *
437  * Finds all posts that have yet to be mailed out, and mails them
438  * out to all subscribers as well as other maintance tasks.
439  *
440  * NOTE: Since 2.7.2 this function is run by scheduled task rather
441  * than standard cron.
442  *
443  * @todo MDL-44734 The function will be split up into seperate tasks.
444  */
445 function forum_cron() {
446     global $CFG, $USER, $DB;
448     $site = get_site();
450     // All users that are subscribed to any post that needs sending,
451     // please increase $CFG->extramemorylimit on large sites that
452     // send notifications to a large number of users.
453     $users = array();
454     $userscount = 0; // Cached user counter - count($users) in PHP is horribly slow!!!
456     // Status arrays.
457     $mailcount  = array();
458     $errorcount = array();
460     // caches
461     $discussions        = array();
462     $forums             = array();
463     $courses            = array();
464     $coursemodules      = array();
465     $subscribedusers    = array();
466     $messageinboundhandlers = array();
468     // Posts older than 2 days will not be mailed.  This is to avoid the problem where
469     // cron has not been running for a long time, and then suddenly people are flooded
470     // with mail from the past few weeks or months
471     $timenow   = time();
472     $endtime   = $timenow - $CFG->maxeditingtime;
473     $starttime = $endtime - 48 * 3600;   // Two days earlier
475     // Get the list of forum subscriptions for per-user per-forum maildigest settings.
476     $digestsset = $DB->get_recordset('forum_digests', null, '', 'id, userid, forum, maildigest');
477     $digests = array();
478     foreach ($digestsset as $thisrow) {
479         if (!isset($digests[$thisrow->forum])) {
480             $digests[$thisrow->forum] = array();
481         }
482         $digests[$thisrow->forum][$thisrow->userid] = $thisrow->maildigest;
483     }
484     $digestsset->close();
486     // Create the generic messageinboundgenerator.
487     $messageinboundgenerator = new \core\message\inbound\address_manager();
488     $messageinboundgenerator->set_handler('\mod_forum\message\inbound\reply_handler');
490     if ($posts = forum_get_unmailed_posts($starttime, $endtime, $timenow)) {
491         // Mark them all now as being mailed.  It's unlikely but possible there
492         // might be an error later so that a post is NOT actually mailed out,
493         // but since mail isn't crucial, we can accept this risk.  Doing it now
494         // prevents the risk of duplicated mails, which is a worse problem.
496         if (!forum_mark_old_posts_as_mailed($endtime)) {
497             mtrace('Errors occurred while trying to mark some posts as being mailed.');
498             return false;  // Don't continue trying to mail them, in case we are in a cron loop
499         }
501         // checking post validity, and adding users to loop through later
502         foreach ($posts as $pid => $post) {
504             $discussionid = $post->discussion;
505             if (!isset($discussions[$discussionid])) {
506                 if ($discussion = $DB->get_record('forum_discussions', array('id'=> $post->discussion))) {
507                     $discussions[$discussionid] = $discussion;
508                     \mod_forum\subscriptions::fill_subscription_cache($discussion->forum);
509                     \mod_forum\subscriptions::fill_discussion_subscription_cache($discussion->forum);
511                 } else {
512                     mtrace('Could not find discussion ' . $discussionid);
513                     unset($posts[$pid]);
514                     continue;
515                 }
516             }
517             $forumid = $discussions[$discussionid]->forum;
518             if (!isset($forums[$forumid])) {
519                 if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
520                     $forums[$forumid] = $forum;
521                 } else {
522                     mtrace('Could not find forum '.$forumid);
523                     unset($posts[$pid]);
524                     continue;
525                 }
526             }
527             $courseid = $forums[$forumid]->course;
528             if (!isset($courses[$courseid])) {
529                 if ($course = $DB->get_record('course', array('id' => $courseid))) {
530                     $courses[$courseid] = $course;
531                 } else {
532                     mtrace('Could not find course '.$courseid);
533                     unset($posts[$pid]);
534                     continue;
535                 }
536             }
537             if (!isset($coursemodules[$forumid])) {
538                 if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
539                     $coursemodules[$forumid] = $cm;
540                 } else {
541                     mtrace('Could not find course module for forum '.$forumid);
542                     unset($posts[$pid]);
543                     continue;
544                 }
545             }
547             // Caching subscribed users of each forum.
548             if (!isset($subscribedusers[$forumid])) {
549                 $modcontext = context_module::instance($coursemodules[$forumid]->id);
550                 if ($subusers = \mod_forum\subscriptions::fetch_subscribed_users($forums[$forumid], 0, $modcontext, 'u.*', true)) {
552                     // Save the Inbound Message datakey here to reduce DB queries later.
553                     $messageinboundgenerator->set_data($pid);
554                     $messageinboundhandlers[$pid] = $messageinboundgenerator->fetch_data_key();
556                     foreach ($subusers as $postuser) {
557                         // this user is subscribed to this forum
558                         $subscribedusers[$forumid][$postuser->id] = $postuser->id;
559                         $userscount++;
560                         if ($userscount > FORUM_CRON_USER_CACHE) {
561                             // Store minimal user info.
562                             $minuser = new stdClass();
563                             $minuser->id = $postuser->id;
564                             $users[$postuser->id] = $minuser;
565                         } else {
566                             // Cache full user record.
567                             forum_cron_minimise_user_record($postuser);
568                             $users[$postuser->id] = $postuser;
569                         }
570                     }
571                     // Release memory.
572                     unset($subusers);
573                     unset($postuser);
574                 }
575             }
576             $mailcount[$pid] = 0;
577             $errorcount[$pid] = 0;
578         }
579     }
581     if ($users && $posts) {
583         $urlinfo = parse_url($CFG->wwwroot);
584         $hostname = $urlinfo['host'];
586         foreach ($users as $userto) {
587             // Terminate if processing of any account takes longer than 2 minutes.
588             core_php_time_limit::raise(120);
590             mtrace('Processing user ' . $userto->id);
592             // Init user caches - we keep the cache for one cycle only, otherwise it could consume too much memory.
593             if (isset($userto->username)) {
594                 $userto = clone($userto);
595             } else {
596                 $userto = $DB->get_record('user', array('id' => $userto->id));
597                 forum_cron_minimise_user_record($userto);
598             }
599             $userto->viewfullnames = array();
600             $userto->canpost       = array();
601             $userto->markposts     = array();
603             // Setup this user so that the capabilities are cached, and environment matches receiving user.
604             cron_setup_user($userto);
606             // Reset the caches.
607             foreach ($coursemodules as $forumid => $unused) {
608                 $coursemodules[$forumid]->cache       = new stdClass();
609                 $coursemodules[$forumid]->cache->caps = array();
610                 unset($coursemodules[$forumid]->uservisible);
611             }
613             foreach ($posts as $pid => $post) {
614                 $discussion = $discussions[$post->discussion];
615                 $forum      = $forums[$discussion->forum];
616                 $course     = $courses[$forum->course];
617                 $cm         =& $coursemodules[$forum->id];
619                 // Do some checks to see if we can bail out now.
621                 // Only active enrolled users are in the list of subscribers.
622                 // This does not necessarily mean that the user is subscribed to the forum or to the discussion though.
623                 if (!isset($subscribedusers[$forum->id][$userto->id])) {
624                     // The user does not subscribe to this forum.
625                     continue;
626                 }
628                 if (!\mod_forum\subscriptions::is_subscribed($userto->id, $forum, $post->discussion, $coursemodules[$forum->id])) {
629                     // The user does not subscribe to this forum, or to this specific discussion.
630                     continue;
631                 }
633                 // Don't send email if the forum is Q&A and the user has not posted.
634                 // Initial topics are still mailed.
635                 if ($forum->type == 'qanda' && !forum_get_user_posted_time($discussion->id, $userto->id) && $pid != $discussion->firstpost) {
636                     mtrace('Did not email ' . $userto->id.' because user has not posted in discussion');
637                     continue;
638                 }
640                 // Get info about the sending user.
641                 if (array_key_exists($post->userid, $users)) {
642                     // We might know the user already.
643                     $userfrom = $users[$post->userid];
644                     if (!isset($userfrom->idnumber)) {
645                         // Minimalised user info, fetch full record.
646                         $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
647                         forum_cron_minimise_user_record($userfrom);
648                     }
650                 } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
651                     forum_cron_minimise_user_record($userfrom);
652                     // Fetch only once if possible, we can add it to user list, it will be skipped anyway.
653                     if ($userscount <= FORUM_CRON_USER_CACHE) {
654                         $userscount++;
655                         $users[$userfrom->id] = $userfrom;
656                     }
657                 } else {
658                     mtrace('Could not find user ' . $post->userid . ', author of post ' . $post->id . '. Unable to send message.');
659                     continue;
660                 }
662                 // Note: If we want to check that userto and userfrom are not the same person this is probably the spot to do it.
664                 // Setup global $COURSE properly - needed for roles and languages.
665                 cron_setup_user($userto, $course);
667                 // Fill caches.
668                 if (!isset($userto->viewfullnames[$forum->id])) {
669                     $modcontext = context_module::instance($cm->id);
670                     $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
671                 }
672                 if (!isset($userto->canpost[$discussion->id])) {
673                     $modcontext = context_module::instance($cm->id);
674                     $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
675                 }
676                 if (!isset($userfrom->groups[$forum->id])) {
677                     if (!isset($userfrom->groups)) {
678                         $userfrom->groups = array();
679                         if (isset($users[$userfrom->id])) {
680                             $users[$userfrom->id]->groups = array();
681                         }
682                     }
683                     $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
684                     if (isset($users[$userfrom->id])) {
685                         $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
686                     }
687                 }
689                 // Make sure groups allow this user to see this email.
690                 if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {
691                     // Groups are being used.
692                     if (!groups_group_exists($discussion->groupid)) {
693                         // Can't find group - be safe and don't this message.
694                         continue;
695                     }
697                     if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $modcontext)) {
698                         // Do not send posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS.
699                         continue;
700                     }
701                 }
703                 // Make sure we're allowed to see the post.
704                 if (!forum_user_can_see_post($forum, $discussion, $post, null, $cm)) {
705                     mtrace('User ' . $userto->id .' can not see ' . $post->id . '. Not sending message.');
706                     continue;
707                 }
709                 // OK so we need to send the email.
711                 // Does the user want this post in a digest?  If so postpone it for now.
712                 $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
714                 if ($maildigest > 0) {
715                     // This user wants the mails to be in digest form.
716                     $queue = new stdClass();
717                     $queue->userid       = $userto->id;
718                     $queue->discussionid = $discussion->id;
719                     $queue->postid       = $post->id;
720                     $queue->timemodified = $post->created;
721                     $DB->insert_record('forum_queue', $queue);
722                     continue;
723                 }
725                 // Prepare to actually send the post now, and build up the content.
727                 $cleanforumname = str_replace('"', "'", strip_tags(format_string($forum->name)));
729                 $userfrom->customheaders = array (
730                     // Headers to make emails easier to track.
731                     'Precedence: Bulk',
732                     'List-Id: "'        . $cleanforumname . '" <moodleforum' . $forum->id . '@' . $hostname.'>',
733                     'List-Help: '       . $CFG->wwwroot . '/mod/forum/view.php?f=' . $forum->id,
734                     'Message-ID: '      . forum_get_email_message_id($post->id, $userto->id, $hostname),
735                     'X-Course-Id: '     . $course->id,
736                     'X-Course-Name: '   . format_string($course->fullname, true)
737                 );
739                 if ($post->parent) {
740                     // This post is a reply, so add headers for threading (see MDL-22551).
741                     $userfrom->customheaders[] = 'In-Reply-To: ' . forum_get_email_message_id($post->parent, $userto->id, $hostname);
742                     $userfrom->customheaders[] = 'References: '  . forum_get_email_message_id($post->parent, $userto->id, $hostname);
743                 }
745                 $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
747                 // Generate a reply-to address from using the Inbound Message handler.
748                 $replyaddress = null;
749                 if ($userto->canpost[$discussion->id] && array_key_exists($post->id, $messageinboundhandlers)) {
750                     $messageinboundgenerator->set_data($post->id, $messageinboundhandlers[$post->id]);
751                     $replyaddress = $messageinboundgenerator->generate($userto->id);
752                 }
754                 $a = new stdClass();
755                 $a->courseshortname = $shortname;
756                 $a->forumname = $cleanforumname;
757                 $a->subject = format_string($post->subject, true);
758                 $postsubject = html_to_text(get_string('postmailsubject', 'forum', $a));
759                 $posttext = forum_make_mail_text($course, $cm, $forum, $discussion, $post, $userfrom, $userto, false,
760                         $replyaddress);
761                 $posthtml = forum_make_mail_html($course, $cm, $forum, $discussion, $post, $userfrom, $userto,
762                         $replyaddress);
764                 // Send the post now!
765                 mtrace('Sending ', '');
767                 $eventdata = new stdClass();
768                 $eventdata->component           = 'mod_forum';
769                 $eventdata->name                = 'posts';
770                 $eventdata->userfrom            = $userfrom;
771                 $eventdata->userto              = $userto;
772                 $eventdata->subject             = $postsubject;
773                 $eventdata->fullmessage         = $posttext;
774                 $eventdata->fullmessageformat   = FORMAT_PLAIN;
775                 $eventdata->fullmessagehtml     = $posthtml;
776                 $eventdata->notification        = 1;
777                 $eventdata->replyto             = $replyaddress;
779                 // If forum_replytouser is not set then send mail using the noreplyaddress.
780                 if (empty($CFG->forum_replytouser)) {
781                     // Clone userfrom as it is referenced by $users.
782                     $cloneduserfrom = clone($userfrom);
783                     $cloneduserfrom->email = $CFG->noreplyaddress;
784                     $eventdata->userfrom = $cloneduserfrom;
785                 }
787                 $smallmessagestrings = new stdClass();
788                 $smallmessagestrings->user          = fullname($userfrom);
789                 $smallmessagestrings->forumname     = "$shortname: " . format_string($forum->name, true) . ": " . $discussion->name;
790                 $smallmessagestrings->message       = $post->message;
792                 // Make sure strings are in message recipients language.
793                 $eventdata->smallmessage = get_string_manager()->get_string('smallmessage', 'forum', $smallmessagestrings, $userto->lang);
795                 $contexturl = new moodle_url('/mod/forum/discuss.php', array('d' => $discussion->id), 'p' . $post->id);
796                 $eventdata->contexturl = $contexturl->out();
797                 $eventdata->contexturlname = $discussion->name;
799                 $mailresult = message_send($eventdata);
800                 if (!$mailresult) {
801                     mtrace("Error: mod/forum/lib.php forum_cron(): Could not send out mail for id $post->id to user $userto->id".
802                             " ($userto->email) .. not trying again.");
803                     $errorcount[$post->id]++;
804                 } else {
805                     $mailcount[$post->id]++;
807                     // Mark post as read if forum_usermarksread is set off.
808                     if (!$CFG->forum_usermarksread) {
809                         $userto->markposts[$post->id] = $post->id;
810                     }
811                 }
813                 mtrace('post ' . $post->id . ': ' . $post->subject);
814             }
816             // Mark processed posts as read.
817             forum_tp_mark_posts_read($userto, $userto->markposts);
818             unset($userto);
819         }
820     }
822     if ($posts) {
823         foreach ($posts as $post) {
824             mtrace($mailcount[$post->id]." users were sent post $post->id, '$post->subject'");
825             if ($errorcount[$post->id]) {
826                 $DB->set_field('forum_posts', 'mailed', FORUM_MAILED_ERROR, array('id' => $post->id));
827             }
828         }
829     }
831     // release some memory
832     unset($subscribedusers);
833     unset($mailcount);
834     unset($errorcount);
836     cron_setup_user();
838     $sitetimezone = $CFG->timezone;
840     // Now see if there are any digest mails waiting to be sent, and if we should send them
842     mtrace('Starting digest processing...');
844     core_php_time_limit::raise(300); // terminate if not able to fetch all digests in 5 minutes
846     if (!isset($CFG->digestmailtimelast)) {    // To catch the first time
847         set_config('digestmailtimelast', 0);
848     }
850     $timenow = time();
851     $digesttime = usergetmidnight($timenow, $sitetimezone) + ($CFG->digestmailtime * 3600);
853     // Delete any really old ones (normally there shouldn't be any)
854     $weekago = $timenow - (7 * 24 * 3600);
855     $DB->delete_records_select('forum_queue', "timemodified < ?", array($weekago));
856     mtrace ('Cleaned old digest records');
858     if ($CFG->digestmailtimelast < $digesttime and $timenow > $digesttime) {
860         mtrace('Sending forum digests: '.userdate($timenow, '', $sitetimezone));
862         $digestposts_rs = $DB->get_recordset_select('forum_queue', "timemodified < ?", array($digesttime));
864         if ($digestposts_rs->valid()) {
866             // We have work to do
867             $usermailcount = 0;
869             //caches - reuse the those filled before too
870             $discussionposts = array();
871             $userdiscussions = array();
873             foreach ($digestposts_rs as $digestpost) {
874                 if (!isset($posts[$digestpost->postid])) {
875                     if ($post = $DB->get_record('forum_posts', array('id' => $digestpost->postid))) {
876                         $posts[$digestpost->postid] = $post;
877                     } else {
878                         continue;
879                     }
880                 }
881                 $discussionid = $digestpost->discussionid;
882                 if (!isset($discussions[$discussionid])) {
883                     if ($discussion = $DB->get_record('forum_discussions', array('id' => $discussionid))) {
884                         $discussions[$discussionid] = $discussion;
885                     } else {
886                         continue;
887                     }
888                 }
889                 $forumid = $discussions[$discussionid]->forum;
890                 if (!isset($forums[$forumid])) {
891                     if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
892                         $forums[$forumid] = $forum;
893                     } else {
894                         continue;
895                     }
896                 }
898                 $courseid = $forums[$forumid]->course;
899                 if (!isset($courses[$courseid])) {
900                     if ($course = $DB->get_record('course', array('id' => $courseid))) {
901                         $courses[$courseid] = $course;
902                     } else {
903                         continue;
904                     }
905                 }
907                 if (!isset($coursemodules[$forumid])) {
908                     if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
909                         $coursemodules[$forumid] = $cm;
910                     } else {
911                         continue;
912                     }
913                 }
914                 $userdiscussions[$digestpost->userid][$digestpost->discussionid] = $digestpost->discussionid;
915                 $discussionposts[$digestpost->discussionid][$digestpost->postid] = $digestpost->postid;
916             }
917             $digestposts_rs->close(); /// Finished iteration, let's close the resultset
919             // Data collected, start sending out emails to each user
920             foreach ($userdiscussions as $userid => $thesediscussions) {
922                 core_php_time_limit::raise(120); // terminate if processing of any account takes longer than 2 minutes
924                 cron_setup_user();
926                 mtrace(get_string('processingdigest', 'forum', $userid), '... ');
928                 // First of all delete all the queue entries for this user
929                 $DB->delete_records_select('forum_queue', "userid = ? AND timemodified < ?", array($userid, $digesttime));
931                 // Init user caches - we keep the cache for one cycle only,
932                 // otherwise it would unnecessarily consume memory.
933                 if (array_key_exists($userid, $users) and isset($users[$userid]->username)) {
934                     $userto = clone($users[$userid]);
935                 } else {
936                     $userto = $DB->get_record('user', array('id' => $userid));
937                     forum_cron_minimise_user_record($userto);
938                 }
939                 $userto->viewfullnames = array();
940                 $userto->canpost       = array();
941                 $userto->markposts     = array();
943                 // Override the language and timezone of the "current" user, so that
944                 // mail is customised for the receiver.
945                 cron_setup_user($userto);
947                 $postsubject = get_string('digestmailsubject', 'forum', format_string($site->shortname, true));
949                 $headerdata = new stdClass();
950                 $headerdata->sitename = format_string($site->fullname, true);
951                 $headerdata->userprefs = $CFG->wwwroot.'/user/edit.php?id='.$userid.'&amp;course='.$site->id;
953                 $posttext = get_string('digestmailheader', 'forum', $headerdata)."\n\n";
954                 $headerdata->userprefs = '<a target="_blank" href="'.$headerdata->userprefs.'">'.get_string('digestmailprefs', 'forum').'</a>';
956                 $posthtml = "<head>";
957 /*                foreach ($CFG->stylesheets as $stylesheet) {
958                     //TODO: MDL-21120
959                     $posthtml .= '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'" />'."\n";
960                 }*/
961                 $posthtml .= "</head>\n<body id=\"email\">\n";
962                 $posthtml .= '<p>'.get_string('digestmailheader', 'forum', $headerdata).'</p><br /><hr size="1" noshade="noshade" />';
964                 foreach ($thesediscussions as $discussionid) {
966                     core_php_time_limit::raise(120);   // to be reset for each post
968                     $discussion = $discussions[$discussionid];
969                     $forum      = $forums[$discussion->forum];
970                     $course     = $courses[$forum->course];
971                     $cm         = $coursemodules[$forum->id];
973                     //override language
974                     cron_setup_user($userto, $course);
976                     // Fill caches
977                     if (!isset($userto->viewfullnames[$forum->id])) {
978                         $modcontext = context_module::instance($cm->id);
979                         $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
980                     }
981                     if (!isset($userto->canpost[$discussion->id])) {
982                         $modcontext = context_module::instance($cm->id);
983                         $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
984                     }
986                     $strforums      = get_string('forums', 'forum');
987                     $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
988                     $canreply       = $userto->canpost[$discussion->id];
989                     $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
991                     $posttext .= "\n \n";
992                     $posttext .= '=====================================================================';
993                     $posttext .= "\n \n";
994                     $posttext .= "$shortname -> $strforums -> ".format_string($forum->name,true);
995                     if ($discussion->name != $forum->name) {
996                         $posttext  .= " -> ".format_string($discussion->name,true);
997                     }
998                     $posttext .= "\n";
999                     $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1000                     $posttext .= "\n";
1002                     $posthtml .= "<p><font face=\"sans-serif\">".
1003                     "<a target=\"_blank\" href=\"$CFG->wwwroot/course/view.php?id=$course->id\">$shortname</a> -> ".
1004                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/index.php?id=$course->id\">$strforums</a> -> ".
1005                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/view.php?f=$forum->id\">".format_string($forum->name,true)."</a>";
1006                     if ($discussion->name == $forum->name) {
1007                         $posthtml .= "</font></p>";
1008                     } else {
1009                         $posthtml .= " -> <a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id\">".format_string($discussion->name,true)."</a></font></p>";
1010                     }
1011                     $posthtml .= '<p>';
1013                     $postsarray = $discussionposts[$discussionid];
1014                     sort($postsarray);
1016                     foreach ($postsarray as $postid) {
1017                         $post = $posts[$postid];
1019                         if (array_key_exists($post->userid, $users)) { // we might know him/her already
1020                             $userfrom = $users[$post->userid];
1021                             if (!isset($userfrom->idnumber)) {
1022                                 $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
1023                                 forum_cron_minimise_user_record($userfrom);
1024                             }
1026                         } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
1027                             forum_cron_minimise_user_record($userfrom);
1028                             if ($userscount <= FORUM_CRON_USER_CACHE) {
1029                                 $userscount++;
1030                                 $users[$userfrom->id] = $userfrom;
1031                             }
1033                         } else {
1034                             mtrace('Could not find user '.$post->userid);
1035                             continue;
1036                         }
1038                         if (!isset($userfrom->groups[$forum->id])) {
1039                             if (!isset($userfrom->groups)) {
1040                                 $userfrom->groups = array();
1041                                 if (isset($users[$userfrom->id])) {
1042                                     $users[$userfrom->id]->groups = array();
1043                                 }
1044                             }
1045                             $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
1046                             if (isset($users[$userfrom->id])) {
1047                                 $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
1048                             }
1049                         }
1051                         $userfrom->customheaders = array ("Precedence: Bulk");
1053                         $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
1054                         if ($maildigest == 2) {
1055                             // Subjects and link only
1056                             $posttext .= "\n";
1057                             $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1058                             $by = new stdClass();
1059                             $by->name = fullname($userfrom);
1060                             $by->date = userdate($post->modified);
1061                             $posttext .= "\n".format_string($post->subject,true).' '.get_string("bynameondate", "forum", $by);
1062                             $posttext .= "\n---------------------------------------------------------------------";
1064                             $by->name = "<a target=\"_blank\" href=\"$CFG->wwwroot/user/view.php?id=$userfrom->id&amp;course=$course->id\">$by->name</a>";
1065                             $posthtml .= '<div><a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id.'#p'.$post->id.'">'.format_string($post->subject,true).'</a> '.get_string("bynameondate", "forum", $by).'</div>';
1067                         } else {
1068                             // The full treatment
1069                             $posttext .= forum_make_mail_text($course, $cm, $forum, $discussion, $post, $userfrom, $userto, true);
1070                             $posthtml .= forum_make_mail_post($course, $cm, $forum, $discussion, $post, $userfrom, $userto, false, $canreply, true, false);
1072                         // Create an array of postid's for this user to mark as read.
1073                             if (!$CFG->forum_usermarksread) {
1074                                 $userto->markposts[$post->id] = $post->id;
1075                             }
1076                         }
1077                     }
1078                     $footerlinks = array();
1079                     if ($canunsubscribe) {
1080                         $footerlinks[] = "<a href=\"$CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id\">" . get_string("unsubscribe", "forum") . "</a>";
1081                     } else {
1082                         $footerlinks[] = get_string("everyoneissubscribed", "forum");
1083                     }
1084                     $footerlinks[] = "<a href='{$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}'>" . get_string("digestmailpost", "forum") . '</a>';
1085                     $posthtml .= "\n<div class='mdl-right'><font size=\"1\">" . implode('&nbsp;', $footerlinks) . '</font></div>';
1086                     $posthtml .= '<hr size="1" noshade="noshade" /></p>';
1087                 }
1088                 $posthtml .= '</body>';
1090                 if (empty($userto->mailformat) || $userto->mailformat != 1) {
1091                     // This user DOESN'T want to receive HTML
1092                     $posthtml = '';
1093                 }
1095                 $attachment = $attachname='';
1096                 // Directly email forum digests rather than sending them via messaging, use the
1097                 // site shortname as 'from name', the noreply address will be used by email_to_user.
1098                 $mailresult = email_to_user($userto, $site->shortname, $postsubject, $posttext, $posthtml, $attachment, $attachname);
1100                 if (!$mailresult) {
1101                     mtrace("ERROR: mod/forum/cron.php: Could not send out digest mail to user $userto->id ".
1102                         "($userto->email)... not trying again.");
1103                 } else {
1104                     mtrace("success.");
1105                     $usermailcount++;
1107                     // Mark post as read if forum_usermarksread is set off
1108                     forum_tp_mark_posts_read($userto, $userto->markposts);
1109                 }
1110             }
1111         }
1112     /// We have finishied all digest emails, update $CFG->digestmailtimelast
1113         set_config('digestmailtimelast', $timenow);
1114     }
1116     cron_setup_user();
1118     if (!empty($usermailcount)) {
1119         mtrace(get_string('digestsentusers', 'forum', $usermailcount));
1120     }
1122     if (!empty($CFG->forum_lastreadclean)) {
1123         $timenow = time();
1124         if ($CFG->forum_lastreadclean + (24*3600) < $timenow) {
1125             set_config('forum_lastreadclean', $timenow);
1126             mtrace('Removing old forum read tracking info...');
1127             forum_tp_clean_read_records();
1128         }
1129     } else {
1130         set_config('forum_lastreadclean', time());
1131     }
1133     return true;
1136 /**
1137  * Builds and returns the body of the email notification in plain text.
1138  *
1139  * @global object
1140  * @global object
1141  * @uses CONTEXT_MODULE
1142  * @param object $course
1143  * @param object $cm
1144  * @param object $forum
1145  * @param object $discussion
1146  * @param object $post
1147  * @param object $userfrom
1148  * @param object $userto
1149  * @param boolean $bare
1150  * @param string $replyaddress The inbound address that a user can reply to the generated e-mail with.
1151  * @return string The email body in plain text format.
1152  */
1153 function forum_make_mail_text($course, $cm, $forum, $discussion, $post, $userfrom, $userto, $bare = false, $replyaddress = null) {
1154     global $CFG, $USER;
1156     $modcontext = context_module::instance($cm->id);
1158     if (!isset($userto->viewfullnames[$forum->id])) {
1159         $viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
1160     } else {
1161         $viewfullnames = $userto->viewfullnames[$forum->id];
1162     }
1164     if (!isset($userto->canpost[$discussion->id])) {
1165         $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1166     } else {
1167         $canreply = $userto->canpost[$discussion->id];
1168     }
1170     $by = New stdClass;
1171     $by->name = fullname($userfrom, $viewfullnames);
1172     $by->date = userdate($post->modified, "", $userto->timezone);
1174     $strbynameondate = get_string('bynameondate', 'forum', $by);
1176     $strforums = get_string('forums', 'forum');
1178     $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
1180     $posttext = '';
1182     if (!$bare) {
1183         $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1184         $posttext  = "$shortname -> $strforums -> ".format_string($forum->name,true);
1186         if ($discussion->name != $forum->name) {
1187             $posttext  .= " -> ".format_string($discussion->name,true);
1188         }
1189     }
1191     // add absolute file links
1192     $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
1194     $posttext .= "\n";
1195     $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1196     $posttext .= "\n---------------------------------------------------------------------\n";
1197     $posttext .= format_string($post->subject,true);
1198     if ($bare) {
1199         $posttext .= " ($CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id#p$post->id)";
1200     }
1201     $posttext .= "\n".$strbynameondate."\n";
1202     $posttext .= "---------------------------------------------------------------------\n";
1203     $posttext .= format_text_email($post->message, $post->messageformat);
1204     $posttext .= "\n\n";
1205     $posttext .= forum_print_attachments($post, $cm, "text");
1207     if (!$bare && $canreply) {
1208         $posttext .= "---------------------------------------------------------------------\n";
1209         $posttext .= get_string("postmailinfo", "forum", $shortname)."\n";
1210         $posttext .= "$CFG->wwwroot/mod/forum/post.php?reply=$post->id\n";
1211     }
1212     if (!$bare && $canunsubscribe) {
1213         $posttext .= "\n---------------------------------------------------------------------\n";
1214         $posttext .= get_string("unsubscribe", "forum");
1215         $posttext .= ": $CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id\n";
1216     }
1218     $posttext .= "\n---------------------------------------------------------------------\n";
1219     $posttext .= get_string("digestmailpost", "forum");
1220     $posttext .= ": {$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}\n";
1222     if ($replyaddress) {
1223         $posttext .= "\n\n" . get_string('replytoforumpost', 'mod_forum', $replyaddress);
1224     }
1226     return $posttext;
1229 /**
1230  * Builds and returns the body of the email notification in html format.
1231  *
1232  * @global object
1233  * @param object $course
1234  * @param object $cm
1235  * @param object $forum
1236  * @param object $discussion
1237  * @param object $post
1238  * @param object $userfrom
1239  * @param object $userto
1240  * @param string $replyaddress The inbound address that a user can reply to the generated e-mail with.
1241  * @return string The email text in HTML format
1242  */
1243 function forum_make_mail_html($course, $cm, $forum, $discussion, $post, $userfrom, $userto, $replyaddress = null) {
1244     global $CFG;
1246     if ($userto->mailformat != 1) {  // Needs to be HTML
1247         return '';
1248     }
1250     if (!isset($userto->canpost[$discussion->id])) {
1251         $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course);
1252     } else {
1253         $canreply = $userto->canpost[$discussion->id];
1254     }
1256     $strforums = get_string('forums', 'forum');
1257     $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
1258     $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1260     $posthtml = '<head>';
1261 /*    foreach ($CFG->stylesheets as $stylesheet) {
1262         //TODO: MDL-21120
1263         $posthtml .= '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'" />'."\n";
1264     }*/
1265     $posthtml .= '</head>';
1266     $posthtml .= "\n<body id=\"email\">\n\n";
1268     $posthtml .= '<div class="navbar">'.
1269     '<a target="_blank" href="'.$CFG->wwwroot.'/course/view.php?id='.$course->id.'">'.$shortname.'</a> &raquo; '.
1270     '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/index.php?id='.$course->id.'">'.$strforums.'</a> &raquo; '.
1271     '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.format_string($forum->name,true).'</a>';
1272     if ($discussion->name == $forum->name) {
1273         $posthtml .= '</div>';
1274     } else {
1275         $posthtml .= ' &raquo; <a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id.'">'.
1276                      format_string($discussion->name,true).'</a></div>';
1277     }
1278     $posthtml .= forum_make_mail_post($course, $cm, $forum, $discussion, $post, $userfrom, $userto, false, $canreply, true, false);
1280     if ($replyaddress) {
1281         $posthtml .= "<p>" . get_string('replytoforumpost_html', 'mod_forum', $replyaddress) . "</p>";
1282     }
1284     $footerlinks = array();
1285     if ($canunsubscribe) {
1286         $footerlinks[] = '<a href="' . $CFG->wwwroot . '/mod/forum/subscribe.php?id=' . $forum->id . '">' . get_string('unsubscribe', 'forum') . '</a>';
1287         $footerlinks[] = '<a href="' . $CFG->wwwroot . '/mod/forum/unsubscribeall.php">' . get_string('unsubscribeall', 'forum') . '</a>';
1288     }
1289     $footerlinks[] = "<a href='{$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}'>" . get_string('digestmailpost', 'forum') . '</a>';
1290     $posthtml .= '<hr /><div class="mdl-align unsubscribelink">' . implode('&nbsp;', $footerlinks) . '</div>';
1292     $posthtml .= '</body>';
1294     return $posthtml;
1298 /**
1299  *
1300  * @param object $course
1301  * @param object $user
1302  * @param object $mod TODO this is not used in this function, refactor
1303  * @param object $forum
1304  * @return object A standard object with 2 variables: info (number of posts for this user) and time (last modified)
1305  */
1306 function forum_user_outline($course, $user, $mod, $forum) {
1307     global $CFG;
1308     require_once("$CFG->libdir/gradelib.php");
1309     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1310     if (empty($grades->items[0]->grades)) {
1311         $grade = false;
1312     } else {
1313         $grade = reset($grades->items[0]->grades);
1314     }
1316     $count = forum_count_user_posts($forum->id, $user->id);
1318     if ($count && $count->postcount > 0) {
1319         $result = new stdClass();
1320         $result->info = get_string("numposts", "forum", $count->postcount);
1321         $result->time = $count->lastpost;
1322         if ($grade) {
1323             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1324         }
1325         return $result;
1326     } else if ($grade) {
1327         $result = new stdClass();
1328         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1330         //datesubmitted == time created. dategraded == time modified or time overridden
1331         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1332         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1333         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1334             $result->time = $grade->dategraded;
1335         } else {
1336             $result->time = $grade->datesubmitted;
1337         }
1339         return $result;
1340     }
1341     return NULL;
1345 /**
1346  * @global object
1347  * @global object
1348  * @param object $coure
1349  * @param object $user
1350  * @param object $mod
1351  * @param object $forum
1352  */
1353 function forum_user_complete($course, $user, $mod, $forum) {
1354     global $CFG,$USER, $OUTPUT;
1355     require_once("$CFG->libdir/gradelib.php");
1357     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1358     if (!empty($grades->items[0]->grades)) {
1359         $grade = reset($grades->items[0]->grades);
1360         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1361         if ($grade->str_feedback) {
1362             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1363         }
1364     }
1366     if ($posts = forum_get_user_posts($forum->id, $user->id)) {
1368         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $course->id)) {
1369             print_error('invalidcoursemodule');
1370         }
1371         $discussions = forum_get_user_involved_discussions($forum->id, $user->id);
1373         foreach ($posts as $post) {
1374             if (!isset($discussions[$post->discussion])) {
1375                 continue;
1376             }
1377             $discussion = $discussions[$post->discussion];
1379             forum_print_post($post, $discussion, $forum, $cm, $course, false, false, false);
1380         }
1381     } else {
1382         echo "<p>".get_string("noposts", "forum")."</p>";
1383     }
1386 /**
1387  * Filters the forum discussions according to groups membership and config.
1388  *
1389  * @since  Moodle 2.8, 2.7.1, 2.6.4
1390  * @param  array $discussions Discussions with new posts array
1391  * @return array Forums with the number of new posts
1392  */
1393 function forum_filter_user_groups_discussions($discussions) {
1395     // Group the remaining discussions posts by their forumid.
1396     $filteredforums = array();
1398     // Discard not visible groups.
1399     foreach ($discussions as $discussion) {
1401         // Course data is already cached.
1402         $instances = get_fast_modinfo($discussion->course)->get_instances();
1403         $forum = $instances['forum'][$discussion->forum];
1405         // Continue if the user should not see this discussion.
1406         if (!forum_is_user_group_discussion($forum, $discussion->groupid)) {
1407             continue;
1408         }
1410         // Grouping results by forum.
1411         if (empty($filteredforums[$forum->instance])) {
1412             $filteredforums[$forum->instance] = new stdClass();
1413             $filteredforums[$forum->instance]->id = $forum->id;
1414             $filteredforums[$forum->instance]->count = 0;
1415         }
1416         $filteredforums[$forum->instance]->count += $discussion->count;
1418     }
1420     return $filteredforums;
1423 /**
1424  * Returns whether the discussion group is visible by the current user or not.
1425  *
1426  * @since Moodle 2.8, 2.7.1, 2.6.4
1427  * @param cm_info $cm The discussion course module
1428  * @param int $discussiongroupid The discussion groupid
1429  * @return bool
1430  */
1431 function forum_is_user_group_discussion(cm_info $cm, $discussiongroupid) {
1433     if ($discussiongroupid == -1 || $cm->effectivegroupmode != SEPARATEGROUPS) {
1434         return true;
1435     }
1437     if (isguestuser()) {
1438         return false;
1439     }
1441     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id)) ||
1442             in_array($discussiongroupid, $cm->get_modinfo()->get_groups($cm->groupingid))) {
1443         return true;
1444     }
1446     return false;
1449 /**
1450  * @global object
1451  * @global object
1452  * @global object
1453  * @param array $courses
1454  * @param array $htmlarray
1455  */
1456 function forum_print_overview($courses,&$htmlarray) {
1457     global $USER, $CFG, $DB, $SESSION;
1459     if (empty($courses) || !is_array($courses) || count($courses) == 0) {
1460         return array();
1461     }
1463     if (!$forums = get_all_instances_in_courses('forum',$courses)) {
1464         return;
1465     }
1467     // Courses to search for new posts
1468     $coursessqls = array();
1469     $params = array();
1470     foreach ($courses as $course) {
1472         // If the user has never entered into the course all posts are pending
1473         if ($course->lastaccess == 0) {
1474             $coursessqls[] = '(d.course = ?)';
1475             $params[] = $course->id;
1477         // Only posts created after the course last access
1478         } else {
1479             $coursessqls[] = '(d.course = ? AND p.created > ?)';
1480             $params[] = $course->id;
1481             $params[] = $course->lastaccess;
1482         }
1483     }
1484     $params[] = $USER->id;
1485     $coursessql = implode(' OR ', $coursessqls);
1487     $sql = "SELECT d.id, d.forum, d.course, d.groupid, COUNT(*) as count "
1488                 .'FROM {forum_discussions} d '
1489                 .'JOIN {forum_posts} p ON p.discussion = d.id '
1490                 ."WHERE ($coursessql) "
1491                 .'AND p.userid != ? '
1492                 .'GROUP BY d.id, d.forum, d.course, d.groupid';
1494     // Avoid warnings.
1495     if (!$discussions = $DB->get_records_sql($sql, $params)) {
1496         $discussions = array();
1497     }
1499     $forumsnewposts = forum_filter_user_groups_discussions($discussions);
1501     // also get all forum tracking stuff ONCE.
1502     $trackingforums = array();
1503     foreach ($forums as $forum) {
1504         if (forum_tp_can_track_forums($forum)) {
1505             $trackingforums[$forum->id] = $forum;
1506         }
1507     }
1509     if (count($trackingforums) > 0) {
1510         $cutoffdate = isset($CFG->forum_oldpostdays) ? (time() - ($CFG->forum_oldpostdays*24*60*60)) : 0;
1511         $sql = 'SELECT d.forum,d.course,COUNT(p.id) AS count '.
1512             ' FROM {forum_posts} p '.
1513             ' JOIN {forum_discussions} d ON p.discussion = d.id '.
1514             ' LEFT JOIN {forum_read} r ON r.postid = p.id AND r.userid = ? WHERE (';
1515         $params = array($USER->id);
1517         foreach ($trackingforums as $track) {
1518             $sql .= '(d.forum = ? AND (d.groupid = -1 OR d.groupid = 0 OR d.groupid = ?)) OR ';
1519             $params[] = $track->id;
1520             if (isset($SESSION->currentgroup[$track->course])) {
1521                 $groupid =  $SESSION->currentgroup[$track->course];
1522             } else {
1523                 // get first groupid
1524                 $groupids = groups_get_all_groups($track->course, $USER->id);
1525                 if ($groupids) {
1526                     reset($groupids);
1527                     $groupid = key($groupids);
1528                     $SESSION->currentgroup[$track->course] = $groupid;
1529                 } else {
1530                     $groupid = 0;
1531                 }
1532                 unset($groupids);
1533             }
1534             $params[] = $groupid;
1535         }
1536         $sql = substr($sql,0,-3); // take off the last OR
1537         $sql .= ') AND p.modified >= ? AND r.id is NULL GROUP BY d.forum,d.course';
1538         $params[] = $cutoffdate;
1540         if (!$unread = $DB->get_records_sql($sql, $params)) {
1541             $unread = array();
1542         }
1543     } else {
1544         $unread = array();
1545     }
1547     if (empty($unread) and empty($forumsnewposts)) {
1548         return;
1549     }
1551     $strforum = get_string('modulename','forum');
1553     foreach ($forums as $forum) {
1554         $str = '';
1555         $count = 0;
1556         $thisunread = 0;
1557         $showunread = false;
1558         // either we have something from logs, or trackposts, or nothing.
1559         if (array_key_exists($forum->id, $forumsnewposts) && !empty($forumsnewposts[$forum->id])) {
1560             $count = $forumsnewposts[$forum->id]->count;
1561         }
1562         if (array_key_exists($forum->id,$unread)) {
1563             $thisunread = $unread[$forum->id]->count;
1564             $showunread = true;
1565         }
1566         if ($count > 0 || $thisunread > 0) {
1567             $str .= '<div class="overview forum"><div class="name">'.$strforum.': <a title="'.$strforum.'" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.
1568                 $forum->name.'</a></div>';
1569             $str .= '<div class="info"><span class="postsincelogin">';
1570             $str .= get_string('overviewnumpostssince', 'forum', $count)."</span>";
1571             if (!empty($showunread)) {
1572                 $str .= '<div class="unreadposts">'.get_string('overviewnumunread', 'forum', $thisunread).'</div>';
1573             }
1574             $str .= '</div></div>';
1575         }
1576         if (!empty($str)) {
1577             if (!array_key_exists($forum->course,$htmlarray)) {
1578                 $htmlarray[$forum->course] = array();
1579             }
1580             if (!array_key_exists('forum',$htmlarray[$forum->course])) {
1581                 $htmlarray[$forum->course]['forum'] = ''; // initialize, avoid warnings
1582             }
1583             $htmlarray[$forum->course]['forum'] .= $str;
1584         }
1585     }
1588 /**
1589  * Given a course and a date, prints a summary of all the new
1590  * messages posted in the course since that date
1591  *
1592  * @global object
1593  * @global object
1594  * @global object
1595  * @uses CONTEXT_MODULE
1596  * @uses VISIBLEGROUPS
1597  * @param object $course
1598  * @param bool $viewfullnames capability
1599  * @param int $timestart
1600  * @return bool success
1601  */
1602 function forum_print_recent_activity($course, $viewfullnames, $timestart) {
1603     global $CFG, $USER, $DB, $OUTPUT;
1605     // do not use log table if possible, it may be huge and is expensive to join with other tables
1607     $allnamefields = user_picture::fields('u', null, 'duserid');
1608     if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
1609                                               d.timestart, d.timeend, $allnamefields
1610                                          FROM {forum_posts} p
1611                                               JOIN {forum_discussions} d ON d.id = p.discussion
1612                                               JOIN {forum} f             ON f.id = d.forum
1613                                               JOIN {user} u              ON u.id = p.userid
1614                                         WHERE p.created > ? AND f.course = ?
1615                                      ORDER BY p.id ASC", array($timestart, $course->id))) { // order by initial posting date
1616          return false;
1617     }
1619     $modinfo = get_fast_modinfo($course);
1621     $groupmodes = array();
1622     $cms    = array();
1624     $strftimerecent = get_string('strftimerecent');
1626     $printposts = array();
1627     foreach ($posts as $post) {
1628         if (!isset($modinfo->instances['forum'][$post->forum])) {
1629             // not visible
1630             continue;
1631         }
1632         $cm = $modinfo->instances['forum'][$post->forum];
1633         if (!$cm->uservisible) {
1634             continue;
1635         }
1636         $context = context_module::instance($cm->id);
1638         if (!has_capability('mod/forum:viewdiscussion', $context)) {
1639             continue;
1640         }
1642         if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
1643           and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
1644             if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1645                 continue;
1646             }
1647         }
1649         // Check that the user can see the discussion.
1650         if (forum_is_user_group_discussion($cm, $post->groupid)) {
1651             $printposts[] = $post;
1652         }
1654     }
1655     unset($posts);
1657     if (!$printposts) {
1658         return false;
1659     }
1661     echo $OUTPUT->heading(get_string('newforumposts', 'forum').':', 3);
1662     echo "\n<ul class='unlist'>\n";
1664     foreach ($printposts as $post) {
1665         $subjectclass = empty($post->parent) ? ' bold' : '';
1667         echo '<li><div class="head">'.
1668                '<div class="date">'.userdate($post->modified, $strftimerecent).'</div>'.
1669                '<div class="name">'.fullname($post, $viewfullnames).'</div>'.
1670              '</div>';
1671         echo '<div class="info'.$subjectclass.'">';
1672         if (empty($post->parent)) {
1673             echo '"<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
1674         } else {
1675             echo '"<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'&amp;parent='.$post->parent.'#p'.$post->id.'">';
1676         }
1677         $post->subject = break_up_long_words(format_string($post->subject, true));
1678         echo $post->subject;
1679         echo "</a>\"</div></li>\n";
1680     }
1682     echo "</ul>\n";
1684     return true;
1687 /**
1688  * Return grade for given user or all users.
1689  *
1690  * @global object
1691  * @global object
1692  * @param object $forum
1693  * @param int $userid optional user id, 0 means all users
1694  * @return array array of grades, false if none
1695  */
1696 function forum_get_user_grades($forum, $userid = 0) {
1697     global $CFG;
1699     require_once($CFG->dirroot.'/rating/lib.php');
1701     $ratingoptions = new stdClass;
1702     $ratingoptions->component = 'mod_forum';
1703     $ratingoptions->ratingarea = 'post';
1705     //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?
1706     $ratingoptions->modulename = 'forum';
1707     $ratingoptions->moduleid   = $forum->id;
1708     $ratingoptions->userid = $userid;
1709     $ratingoptions->aggregationmethod = $forum->assessed;
1710     $ratingoptions->scaleid = $forum->scale;
1711     $ratingoptions->itemtable = 'forum_posts';
1712     $ratingoptions->itemtableusercolumn = 'userid';
1714     $rm = new rating_manager();
1715     return $rm->get_user_grades($ratingoptions);
1718 /**
1719  * Update activity grades
1720  *
1721  * @category grade
1722  * @param object $forum
1723  * @param int $userid specific user only, 0 means all
1724  * @param boolean $nullifnone return null if grade does not exist
1725  * @return void
1726  */
1727 function forum_update_grades($forum, $userid=0, $nullifnone=true) {
1728     global $CFG, $DB;
1729     require_once($CFG->libdir.'/gradelib.php');
1731     if (!$forum->assessed) {
1732         forum_grade_item_update($forum);
1734     } else if ($grades = forum_get_user_grades($forum, $userid)) {
1735         forum_grade_item_update($forum, $grades);
1737     } else if ($userid and $nullifnone) {
1738         $grade = new stdClass();
1739         $grade->userid   = $userid;
1740         $grade->rawgrade = NULL;
1741         forum_grade_item_update($forum, $grade);
1743     } else {
1744         forum_grade_item_update($forum);
1745     }
1748 /**
1749  * Create/update grade item for given forum
1750  *
1751  * @category grade
1752  * @uses GRADE_TYPE_NONE
1753  * @uses GRADE_TYPE_VALUE
1754  * @uses GRADE_TYPE_SCALE
1755  * @param stdClass $forum Forum object with extra cmidnumber
1756  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1757  * @return int 0 if ok
1758  */
1759 function forum_grade_item_update($forum, $grades=NULL) {
1760     global $CFG;
1761     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
1762         require_once($CFG->libdir.'/gradelib.php');
1763     }
1765     $params = array('itemname'=>$forum->name, 'idnumber'=>$forum->cmidnumber);
1767     if (!$forum->assessed or $forum->scale == 0) {
1768         $params['gradetype'] = GRADE_TYPE_NONE;
1770     } else if ($forum->scale > 0) {
1771         $params['gradetype'] = GRADE_TYPE_VALUE;
1772         $params['grademax']  = $forum->scale;
1773         $params['grademin']  = 0;
1775     } else if ($forum->scale < 0) {
1776         $params['gradetype'] = GRADE_TYPE_SCALE;
1777         $params['scaleid']   = -$forum->scale;
1778     }
1780     if ($grades  === 'reset') {
1781         $params['reset'] = true;
1782         $grades = NULL;
1783     }
1785     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, $grades, $params);
1788 /**
1789  * Delete grade item for given forum
1790  *
1791  * @category grade
1792  * @param stdClass $forum Forum object
1793  * @return grade_item
1794  */
1795 function forum_grade_item_delete($forum) {
1796     global $CFG;
1797     require_once($CFG->libdir.'/gradelib.php');
1799     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, NULL, array('deleted'=>1));
1803 /**
1804  * This function returns if a scale is being used by one forum
1805  *
1806  * @global object
1807  * @param int $forumid
1808  * @param int $scaleid negative number
1809  * @return bool
1810  */
1811 function forum_scale_used ($forumid,$scaleid) {
1812     global $DB;
1813     $return = false;
1815     $rec = $DB->get_record("forum",array("id" => "$forumid","scale" => "-$scaleid"));
1817     if (!empty($rec) && !empty($scaleid)) {
1818         $return = true;
1819     }
1821     return $return;
1824 /**
1825  * Checks if scale is being used by any instance of forum
1826  *
1827  * This is used to find out if scale used anywhere
1828  *
1829  * @global object
1830  * @param $scaleid int
1831  * @return boolean True if the scale is used by any forum
1832  */
1833 function forum_scale_used_anywhere($scaleid) {
1834     global $DB;
1835     if ($scaleid and $DB->record_exists('forum', array('scale' => -$scaleid))) {
1836         return true;
1837     } else {
1838         return false;
1839     }
1842 // SQL FUNCTIONS ///////////////////////////////////////////////////////////
1844 /**
1845  * Gets a post with all info ready for forum_print_post
1846  * Most of these joins are just to get the forum id
1847  *
1848  * @global object
1849  * @global object
1850  * @param int $postid
1851  * @return mixed array of posts or false
1852  */
1853 function forum_get_post_full($postid) {
1854     global $CFG, $DB;
1856     $allnames = get_all_user_name_fields(true, 'u');
1857     return $DB->get_record_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1858                              FROM {forum_posts} p
1859                                   JOIN {forum_discussions} d ON p.discussion = d.id
1860                                   LEFT JOIN {user} u ON p.userid = u.id
1861                             WHERE p.id = ?", array($postid));
1864 /**
1865  * Gets all posts in discussion including top parent.
1866  *
1867  * @global object
1868  * @global object
1869  * @global object
1870  * @param int $discussionid
1871  * @param string $sort
1872  * @param bool $tracking does user track the forum?
1873  * @return array of posts
1874  */
1875 function forum_get_all_discussion_posts($discussionid, $sort, $tracking=false) {
1876     global $CFG, $DB, $USER;
1878     $tr_sel  = "";
1879     $tr_join = "";
1880     $params = array();
1882     if ($tracking) {
1883         $now = time();
1884         $cutoffdate = $now - ($CFG->forum_oldpostdays * 24 * 3600);
1885         $tr_sel  = ", fr.id AS postread";
1886         $tr_join = "LEFT JOIN {forum_read} fr ON (fr.postid = p.id AND fr.userid = ?)";
1887         $params[] = $USER->id;
1888     }
1890     $allnames = get_all_user_name_fields(true, 'u');
1891     $params[] = $discussionid;
1892     if (!$posts = $DB->get_records_sql("SELECT p.*, $allnames, u.email, u.picture, u.imagealt $tr_sel
1893                                      FROM {forum_posts} p
1894                                           LEFT JOIN {user} u ON p.userid = u.id
1895                                           $tr_join
1896                                     WHERE p.discussion = ?
1897                                  ORDER BY $sort", $params)) {
1898         return array();
1899     }
1901     foreach ($posts as $pid=>$p) {
1902         if ($tracking) {
1903             if (forum_tp_is_post_old($p)) {
1904                  $posts[$pid]->postread = true;
1905             }
1906         }
1907         if (!$p->parent) {
1908             continue;
1909         }
1910         if (!isset($posts[$p->parent])) {
1911             continue; // parent does not exist??
1912         }
1913         if (!isset($posts[$p->parent]->children)) {
1914             $posts[$p->parent]->children = array();
1915         }
1916         $posts[$p->parent]->children[$pid] =& $posts[$pid];
1917     }
1919     return $posts;
1922 /**
1923  * An array of forum objects that the user is allowed to read/search through.
1924  *
1925  * @global object
1926  * @global object
1927  * @global object
1928  * @param int $userid
1929  * @param int $courseid if 0, we look for forums throughout the whole site.
1930  * @return array of forum objects, or false if no matches
1931  *         Forum objects have the following attributes:
1932  *         id, type, course, cmid, cmvisible, cmgroupmode, accessallgroups,
1933  *         viewhiddentimedposts
1934  */
1935 function forum_get_readable_forums($userid, $courseid=0) {
1937     global $CFG, $DB, $USER;
1938     require_once($CFG->dirroot.'/course/lib.php');
1940     if (!$forummod = $DB->get_record('modules', array('name' => 'forum'))) {
1941         print_error('notinstalled', 'forum');
1942     }
1944     if ($courseid) {
1945         $courses = $DB->get_records('course', array('id' => $courseid));
1946     } else {
1947         // If no course is specified, then the user can see SITE + his courses.
1948         $courses1 = $DB->get_records('course', array('id' => SITEID));
1949         $courses2 = enrol_get_users_courses($userid, true, array('modinfo'));
1950         $courses = array_merge($courses1, $courses2);
1951     }
1952     if (!$courses) {
1953         return array();
1954     }
1956     $readableforums = array();
1958     foreach ($courses as $course) {
1960         $modinfo = get_fast_modinfo($course);
1962         if (empty($modinfo->instances['forum'])) {
1963             // hmm, no forums?
1964             continue;
1965         }
1967         $courseforums = $DB->get_records('forum', array('course' => $course->id));
1969         foreach ($modinfo->instances['forum'] as $forumid => $cm) {
1970             if (!$cm->uservisible or !isset($courseforums[$forumid])) {
1971                 continue;
1972             }
1973             $context = context_module::instance($cm->id);
1974             $forum = $courseforums[$forumid];
1975             $forum->context = $context;
1976             $forum->cm = $cm;
1978             if (!has_capability('mod/forum:viewdiscussion', $context)) {
1979                 continue;
1980             }
1982          /// group access
1983             if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
1985                 $forum->onlygroups = $modinfo->get_groups($cm->groupingid);
1986                 $forum->onlygroups[] = -1;
1987             }
1989         /// hidden timed discussions
1990             $forum->viewhiddentimedposts = true;
1991             if (!empty($CFG->forum_enabletimedposts)) {
1992                 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1993                     $forum->viewhiddentimedposts = false;
1994                 }
1995             }
1997         /// qanda access
1998             if ($forum->type == 'qanda'
1999                     && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
2001                 // We need to check whether the user has posted in the qanda forum.
2002                 $forum->onlydiscussions = array();  // Holds discussion ids for the discussions
2003                                                     // the user is allowed to see in this forum.
2004                 if ($discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $USER->id)) {
2005                     foreach ($discussionspostedin as $d) {
2006                         $forum->onlydiscussions[] = $d->id;
2007                     }
2008                 }
2009             }
2011             $readableforums[$forum->id] = $forum;
2012         }
2014         unset($modinfo);
2016     } // End foreach $courses
2018     return $readableforums;
2021 /**
2022  * Returns a list of posts found using an array of search terms.
2023  *
2024  * @global object
2025  * @global object
2026  * @global object
2027  * @param array $searchterms array of search terms, e.g. word +word -word
2028  * @param int $courseid if 0, we search through the whole site
2029  * @param int $limitfrom
2030  * @param int $limitnum
2031  * @param int &$totalcount
2032  * @param string $extrasql
2033  * @return array|bool Array of posts found or false
2034  */
2035 function forum_search_posts($searchterms, $courseid=0, $limitfrom=0, $limitnum=50,
2036                             &$totalcount, $extrasql='') {
2037     global $CFG, $DB, $USER;
2038     require_once($CFG->libdir.'/searchlib.php');
2040     $forums = forum_get_readable_forums($USER->id, $courseid);
2042     if (count($forums) == 0) {
2043         $totalcount = 0;
2044         return false;
2045     }
2047     $now = round(time(), -2); // db friendly
2049     $fullaccess = array();
2050     $where = array();
2051     $params = array();
2053     foreach ($forums as $forumid => $forum) {
2054         $select = array();
2056         if (!$forum->viewhiddentimedposts) {
2057             $select[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
2058             $params = array_merge($params, array('userid'.$forumid=>$USER->id, 'timestart'.$forumid=>$now, 'timeend'.$forumid=>$now));
2059         }
2061         $cm = $forum->cm;
2062         $context = $forum->context;
2064         if ($forum->type == 'qanda'
2065             && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
2066             if (!empty($forum->onlydiscussions)) {
2067                 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forum->onlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
2068                 $params = array_merge($params, $discussionid_params);
2069                 $select[] = "(d.id $discussionid_sql OR p.parent = 0)";
2070             } else {
2071                 $select[] = "p.parent = 0";
2072             }
2073         }
2075         if (!empty($forum->onlygroups)) {
2076             list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($forum->onlygroups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
2077             $params = array_merge($params, $groupid_params);
2078             $select[] = "d.groupid $groupid_sql";
2079         }
2081         if ($select) {
2082             $selects = implode(" AND ", $select);
2083             $where[] = "(d.forum = :forum{$forumid} AND $selects)";
2084             $params['forum'.$forumid] = $forumid;
2085         } else {
2086             $fullaccess[] = $forumid;
2087         }
2088     }
2090     if ($fullaccess) {
2091         list($fullid_sql, $fullid_params) = $DB->get_in_or_equal($fullaccess, SQL_PARAMS_NAMED, 'fula');
2092         $params = array_merge($params, $fullid_params);
2093         $where[] = "(d.forum $fullid_sql)";
2094     }
2096     $selectdiscussion = "(".implode(" OR ", $where).")";
2098     $messagesearch = '';
2099     $searchstring = '';
2101     // Need to concat these back together for parser to work.
2102     foreach($searchterms as $searchterm){
2103         if ($searchstring != '') {
2104             $searchstring .= ' ';
2105         }
2106         $searchstring .= $searchterm;
2107     }
2109     // We need to allow quoted strings for the search. The quotes *should* be stripped
2110     // by the parser, but this should be examined carefully for security implications.
2111     $searchstring = str_replace("\\\"","\"",$searchstring);
2112     $parser = new search_parser();
2113     $lexer = new search_lexer($parser);
2115     if ($lexer->parse($searchstring)) {
2116         $parsearray = $parser->get_parsed_array();
2117     // Experimental feature under 1.8! MDL-8830
2118     // Use alternative text searches if defined
2119     // This feature only works under mysql until properly implemented for other DBs
2120     // Requires manual creation of text index for forum_posts before enabling it:
2121     // CREATE FULLTEXT INDEX foru_post_tix ON [prefix]forum_posts (subject, message)
2122     // Experimental feature under 1.8! MDL-8830
2123         if (!empty($CFG->forum_usetextsearches)) {
2124             list($messagesearch, $msparams) = search_generate_text_SQL($parsearray, 'p.message', 'p.subject',
2125                                                  'p.userid', 'u.id', 'u.firstname',
2126                                                  'u.lastname', 'p.modified', 'd.forum');
2127         } else {
2128             list($messagesearch, $msparams) = search_generate_SQL($parsearray, 'p.message', 'p.subject',
2129                                                  'p.userid', 'u.id', 'u.firstname',
2130                                                  'u.lastname', 'p.modified', 'd.forum');
2131         }
2132         $params = array_merge($params, $msparams);
2133     }
2135     $fromsql = "{forum_posts} p,
2136                   {forum_discussions} d,
2137                   {user} u";
2139     $selectsql = " $messagesearch
2140                AND p.discussion = d.id
2141                AND p.userid = u.id
2142                AND $selectdiscussion
2143                    $extrasql";
2145     $countsql = "SELECT COUNT(*)
2146                    FROM $fromsql
2147                   WHERE $selectsql";
2149     $allnames = get_all_user_name_fields(true, 'u');
2150     $searchsql = "SELECT p.*,
2151                          d.forum,
2152                          $allnames,
2153                          u.email,
2154                          u.picture,
2155                          u.imagealt
2156                     FROM $fromsql
2157                    WHERE $selectsql
2158                 ORDER BY p.modified DESC";
2160     $totalcount = $DB->count_records_sql($countsql, $params);
2162     return $DB->get_records_sql($searchsql, $params, $limitfrom, $limitnum);
2165 /**
2166  * Returns a list of all new posts that have not been mailed yet
2167  *
2168  * @param int $starttime posts created after this time
2169  * @param int $endtime posts created before this
2170  * @param int $now used for timed discussions only
2171  * @return array
2172  */
2173 function forum_get_unmailed_posts($starttime, $endtime, $now=null) {
2174     global $CFG, $DB;
2176     $params = array();
2177     $params['mailed'] = FORUM_MAILED_PENDING;
2178     $params['ptimestart'] = $starttime;
2179     $params['ptimeend'] = $endtime;
2180     $params['mailnow'] = 1;
2182     if (!empty($CFG->forum_enabletimedposts)) {
2183         if (empty($now)) {
2184             $now = time();
2185         }
2186         $timedsql = "AND (d.timestart < :dtimestart AND (d.timeend = 0 OR d.timeend > :dtimeend))";
2187         $params['dtimestart'] = $now;
2188         $params['dtimeend'] = $now;
2189     } else {
2190         $timedsql = "";
2191     }
2193     return $DB->get_records_sql("SELECT p.*, d.course, d.forum
2194                                  FROM {forum_posts} p
2195                                  JOIN {forum_discussions} d ON d.id = p.discussion
2196                                  WHERE p.mailed = :mailed
2197                                  AND p.created >= :ptimestart
2198                                  AND (p.created < :ptimeend OR p.mailnow = :mailnow)
2199                                  $timedsql
2200                                  ORDER BY p.modified ASC", $params);
2203 /**
2204  * Marks posts before a certain time as being mailed already
2205  *
2206  * @global object
2207  * @global object
2208  * @param int $endtime
2209  * @param int $now Defaults to time()
2210  * @return bool
2211  */
2212 function forum_mark_old_posts_as_mailed($endtime, $now=null) {
2213     global $CFG, $DB;
2215     if (empty($now)) {
2216         $now = time();
2217     }
2219     $params = array();
2220     $params['mailedsuccess'] = FORUM_MAILED_SUCCESS;
2221     $params['now'] = $now;
2222     $params['endtime'] = $endtime;
2223     $params['mailnow'] = 1;
2224     $params['mailedpending'] = FORUM_MAILED_PENDING;
2226     if (empty($CFG->forum_enabletimedposts)) {
2227         return $DB->execute("UPDATE {forum_posts}
2228                              SET mailed = :mailedsuccess
2229                              WHERE (created < :endtime OR mailnow = :mailnow)
2230                              AND mailed = :mailedpending", $params);
2231     } else {
2232         return $DB->execute("UPDATE {forum_posts}
2233                              SET mailed = :mailedsuccess
2234                              WHERE discussion NOT IN (SELECT d.id
2235                                                       FROM {forum_discussions} d
2236                                                       WHERE d.timestart > :now)
2237                              AND (created < :endtime OR mailnow = :mailnow)
2238                              AND mailed = :mailedpending", $params);
2239     }
2242 /**
2243  * Get all the posts for a user in a forum suitable for forum_print_post
2244  *
2245  * @global object
2246  * @global object
2247  * @uses CONTEXT_MODULE
2248  * @return array
2249  */
2250 function forum_get_user_posts($forumid, $userid) {
2251     global $CFG, $DB;
2253     $timedsql = "";
2254     $params = array($forumid, $userid);
2256     if (!empty($CFG->forum_enabletimedposts)) {
2257         $cm = get_coursemodule_from_instance('forum', $forumid);
2258         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2259             $now = time();
2260             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2261             $params[] = $now;
2262             $params[] = $now;
2263         }
2264     }
2266     $allnames = get_all_user_name_fields(true, 'u');
2267     return $DB->get_records_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
2268                               FROM {forum} f
2269                                    JOIN {forum_discussions} d ON d.forum = f.id
2270                                    JOIN {forum_posts} p       ON p.discussion = d.id
2271                                    JOIN {user} u              ON u.id = p.userid
2272                              WHERE f.id = ?
2273                                    AND p.userid = ?
2274                                    $timedsql
2275                           ORDER BY p.modified ASC", $params);
2278 /**
2279  * Get all the discussions user participated in
2280  *
2281  * @global object
2282  * @global object
2283  * @uses CONTEXT_MODULE
2284  * @param int $forumid
2285  * @param int $userid
2286  * @return array Array or false
2287  */
2288 function forum_get_user_involved_discussions($forumid, $userid) {
2289     global $CFG, $DB;
2291     $timedsql = "";
2292     $params = array($forumid, $userid);
2293     if (!empty($CFG->forum_enabletimedposts)) {
2294         $cm = get_coursemodule_from_instance('forum', $forumid);
2295         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2296             $now = time();
2297             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2298             $params[] = $now;
2299             $params[] = $now;
2300         }
2301     }
2303     return $DB->get_records_sql("SELECT DISTINCT d.*
2304                               FROM {forum} f
2305                                    JOIN {forum_discussions} d ON d.forum = f.id
2306                                    JOIN {forum_posts} p       ON p.discussion = d.id
2307                              WHERE f.id = ?
2308                                    AND p.userid = ?
2309                                    $timedsql", $params);
2312 /**
2313  * Get all the posts for a user in a forum suitable for forum_print_post
2314  *
2315  * @global object
2316  * @global object
2317  * @param int $forumid
2318  * @param int $userid
2319  * @return array of counts or false
2320  */
2321 function forum_count_user_posts($forumid, $userid) {
2322     global $CFG, $DB;
2324     $timedsql = "";
2325     $params = array($forumid, $userid);
2326     if (!empty($CFG->forum_enabletimedposts)) {
2327         $cm = get_coursemodule_from_instance('forum', $forumid);
2328         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2329             $now = time();
2330             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2331             $params[] = $now;
2332             $params[] = $now;
2333         }
2334     }
2336     return $DB->get_record_sql("SELECT COUNT(p.id) AS postcount, MAX(p.modified) AS lastpost
2337                              FROM {forum} f
2338                                   JOIN {forum_discussions} d ON d.forum = f.id
2339                                   JOIN {forum_posts} p       ON p.discussion = d.id
2340                                   JOIN {user} u              ON u.id = p.userid
2341                             WHERE f.id = ?
2342                                   AND p.userid = ?
2343                                   $timedsql", $params);
2346 /**
2347  * Given a log entry, return the forum post details for it.
2348  *
2349  * @global object
2350  * @global object
2351  * @param object $log
2352  * @return array|null
2353  */
2354 function forum_get_post_from_log($log) {
2355     global $CFG, $DB;
2357     $allnames = get_all_user_name_fields(true, 'u');
2358     if ($log->action == "add post") {
2360         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2361                                  FROM {forum_discussions} d,
2362                                       {forum_posts} p,
2363                                       {forum} f,
2364                                       {user} u
2365                                 WHERE p.id = ?
2366                                   AND d.id = p.discussion
2367                                   AND p.userid = u.id
2368                                   AND u.deleted <> '1'
2369                                   AND f.id = d.forum", array($log->info));
2372     } else if ($log->action == "add discussion") {
2374         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2375                                  FROM {forum_discussions} d,
2376                                       {forum_posts} p,
2377                                       {forum} f,
2378                                       {user} u
2379                                 WHERE d.id = ?
2380                                   AND d.firstpost = p.id
2381                                   AND p.userid = u.id
2382                                   AND u.deleted <> '1'
2383                                   AND f.id = d.forum", array($log->info));
2384     }
2385     return NULL;
2388 /**
2389  * Given a discussion id, return the first post from the discussion
2390  *
2391  * @global object
2392  * @global object
2393  * @param int $dicsussionid
2394  * @return array
2395  */
2396 function forum_get_firstpost_from_discussion($discussionid) {
2397     global $CFG, $DB;
2399     return $DB->get_record_sql("SELECT p.*
2400                              FROM {forum_discussions} d,
2401                                   {forum_posts} p
2402                             WHERE d.id = ?
2403                               AND d.firstpost = p.id ", array($discussionid));
2406 /**
2407  * Returns an array of counts of replies to each discussion
2408  *
2409  * @global object
2410  * @global object
2411  * @param int $forumid
2412  * @param string $forumsort
2413  * @param int $limit
2414  * @param int $page
2415  * @param int $perpage
2416  * @return array
2417  */
2418 function forum_count_discussion_replies($forumid, $forumsort="", $limit=-1, $page=-1, $perpage=0) {
2419     global $CFG, $DB;
2421     if ($limit > 0) {
2422         $limitfrom = 0;
2423         $limitnum  = $limit;
2424     } else if ($page != -1) {
2425         $limitfrom = $page*$perpage;
2426         $limitnum  = $perpage;
2427     } else {
2428         $limitfrom = 0;
2429         $limitnum  = 0;
2430     }
2432     if ($forumsort == "") {
2433         $orderby = "";
2434         $groupby = "";
2436     } else {
2437         $orderby = "ORDER BY $forumsort";
2438         $groupby = ", ".strtolower($forumsort);
2439         $groupby = str_replace('desc', '', $groupby);
2440         $groupby = str_replace('asc', '', $groupby);
2441     }
2443     if (($limitfrom == 0 and $limitnum == 0) or $forumsort == "") {
2444         $sql = "SELECT p.discussion, COUNT(p.id) AS replies, MAX(p.id) AS lastpostid
2445                   FROM {forum_posts} p
2446                        JOIN {forum_discussions} d ON p.discussion = d.id
2447                  WHERE p.parent > 0 AND d.forum = ?
2448               GROUP BY p.discussion";
2449         return $DB->get_records_sql($sql, array($forumid));
2451     } else {
2452         $sql = "SELECT p.discussion, (COUNT(p.id) - 1) AS replies, MAX(p.id) AS lastpostid
2453                   FROM {forum_posts} p
2454                        JOIN {forum_discussions} d ON p.discussion = d.id
2455                  WHERE d.forum = ?
2456               GROUP BY p.discussion $groupby
2457               $orderby";
2458         return $DB->get_records_sql("SELECT * FROM ($sql) sq", array($forumid), $limitfrom, $limitnum);
2459     }
2462 /**
2463  * @global object
2464  * @global object
2465  * @global object
2466  * @staticvar array $cache
2467  * @param object $forum
2468  * @param object $cm
2469  * @param object $course
2470  * @return mixed
2471  */
2472 function forum_count_discussions($forum, $cm, $course) {
2473     global $CFG, $DB, $USER;
2475     static $cache = array();
2477     $now = round(time(), -2); // db cache friendliness
2479     $params = array($course->id);
2481     if (!isset($cache[$course->id])) {
2482         if (!empty($CFG->forum_enabletimedposts)) {
2483             $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
2484             $params[] = $now;
2485             $params[] = $now;
2486         } else {
2487             $timedsql = "";
2488         }
2490         $sql = "SELECT f.id, COUNT(d.id) as dcount
2491                   FROM {forum} f
2492                        JOIN {forum_discussions} d ON d.forum = f.id
2493                  WHERE f.course = ?
2494                        $timedsql
2495               GROUP BY f.id";
2497         if ($counts = $DB->get_records_sql($sql, $params)) {
2498             foreach ($counts as $count) {
2499                 $counts[$count->id] = $count->dcount;
2500             }
2501             $cache[$course->id] = $counts;
2502         } else {
2503             $cache[$course->id] = array();
2504         }
2505     }
2507     if (empty($cache[$course->id][$forum->id])) {
2508         return 0;
2509     }
2511     $groupmode = groups_get_activity_groupmode($cm, $course);
2513     if ($groupmode != SEPARATEGROUPS) {
2514         return $cache[$course->id][$forum->id];
2515     }
2517     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
2518         return $cache[$course->id][$forum->id];
2519     }
2521     require_once($CFG->dirroot.'/course/lib.php');
2523     $modinfo = get_fast_modinfo($course);
2525     $mygroups = $modinfo->get_groups($cm->groupingid);
2527     // add all groups posts
2528     $mygroups[-1] = -1;
2530     list($mygroups_sql, $params) = $DB->get_in_or_equal($mygroups);
2531     $params[] = $forum->id;
2533     if (!empty($CFG->forum_enabletimedposts)) {
2534         $timedsql = "AND d.timestart < $now AND (d.timeend = 0 OR d.timeend > $now)";
2535         $params[] = $now;
2536         $params[] = $now;
2537     } else {
2538         $timedsql = "";
2539     }
2541     $sql = "SELECT COUNT(d.id)
2542               FROM {forum_discussions} d
2543              WHERE d.groupid $mygroups_sql AND d.forum = ?
2544                    $timedsql";
2546     return $DB->get_field_sql($sql, $params);
2549 /**
2550  * Get all discussions in a forum
2551  *
2552  * @global object
2553  * @global object
2554  * @global object
2555  * @uses CONTEXT_MODULE
2556  * @uses VISIBLEGROUPS
2557  * @param object $cm
2558  * @param string $forumsort
2559  * @param bool $fullpost
2560  * @param int $unused
2561  * @param int $limit
2562  * @param bool $userlastmodified
2563  * @param int $page
2564  * @param int $perpage
2565  * @return array
2566  */
2567 function forum_get_discussions($cm, $forumsort="d.timemodified DESC", $fullpost=true, $unused=-1, $limit=-1, $userlastmodified=false, $page=-1, $perpage=0) {
2568     global $CFG, $DB, $USER;
2570     $timelimit = '';
2572     $now = round(time(), -2);
2573     $params = array($cm->instance);
2575     $modcontext = context_module::instance($cm->id);
2577     if (!has_capability('mod/forum:viewdiscussion', $modcontext)) { /// User must have perms to view discussions
2578         return array();
2579     }
2581     if (!empty($CFG->forum_enabletimedposts)) { /// Users must fulfill timed posts
2583         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2584             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2585             $params[] = $now;
2586             $params[] = $now;
2587             if (isloggedin()) {
2588                 $timelimit .= " OR d.userid = ?";
2589                 $params[] = $USER->id;
2590             }
2591             $timelimit .= ")";
2592         }
2593     }
2595     if ($limit > 0) {
2596         $limitfrom = 0;
2597         $limitnum  = $limit;
2598     } else if ($page != -1) {
2599         $limitfrom = $page*$perpage;
2600         $limitnum  = $perpage;
2601     } else {
2602         $limitfrom = 0;
2603         $limitnum  = 0;
2604     }
2606     $groupmode    = groups_get_activity_groupmode($cm);
2607     $currentgroup = groups_get_activity_group($cm);
2609     if ($groupmode) {
2610         if (empty($modcontext)) {
2611             $modcontext = context_module::instance($cm->id);
2612         }
2614         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2615             if ($currentgroup) {
2616                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2617                 $params[] = $currentgroup;
2618             } else {
2619                 $groupselect = "";
2620             }
2622         } else {
2623             //seprate groups without access all
2624             if ($currentgroup) {
2625                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2626                 $params[] = $currentgroup;
2627             } else {
2628                 $groupselect = "AND d.groupid = -1";
2629             }
2630         }
2631     } else {
2632         $groupselect = "";
2633     }
2636     if (empty($forumsort)) {
2637         $forumsort = "d.timemodified DESC";
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');
2650         $umtable  = " LEFT JOIN {user} um ON (d.usermodified = um.id)";
2651     }
2653     $allnames = get_all_user_name_fields(true, 'u');
2654     $sql = "SELECT $postdata, d.name, d.timemodified, d.usermodified, d.groupid, d.timestart, d.timeend, $allnames,
2655                    u.email, u.picture, u.imagealt $umfields
2656               FROM {forum_discussions} d
2657                    JOIN {forum_posts} p ON p.discussion = d.id
2658                    JOIN {user} u ON p.userid = u.id
2659                    $umtable
2660              WHERE d.forum = ? AND p.parent = 0
2661                    $timelimit $groupselect
2662           ORDER BY $forumsort";
2663     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
2666 /**
2667  * Gets the neighbours (previous and next) of a discussion.
2668  *
2669  * The calculation is based on the timemodified of the discussion and does not handle
2670  * the neighbours having an identical timemodified. The reason is that we do not have any
2671  * other mean to sort the records, e.g. we cannot use IDs as a greater ID can have a lower
2672  * timemodified.
2673  *
2674  * Please note that this does not check whether or not the discussion passed is accessible
2675  * by the user, it simply uses it as a reference to find the neighbours. On the other hand,
2676  * the returned neighbours are checked and are accessible to the current user.
2677  *
2678  * @param object $cm The CM record.
2679  * @param object $discussion The discussion record.
2680  * @return array That always contains the keys 'prev' and 'next'. When there is a result
2681  *               they contain the record with minimal information such as 'id' and 'name'.
2682  *               When the neighbour is not found the value is false.
2683  */
2684 function forum_get_discussion_neighbours($cm, $discussion) {
2685     global $CFG, $DB, $USER;
2687     if ($cm->instance != $discussion->forum) {
2688         throw new coding_exception('Discussion is not part of the same forum.');
2689     }
2691     $neighbours = array('prev' => false, 'next' => false);
2692     $now = round(time(), -2);
2693     $params = array();
2695     $modcontext = context_module::instance($cm->id);
2696     $groupmode    = groups_get_activity_groupmode($cm);
2697     $currentgroup = groups_get_activity_group($cm);
2699     // Users must fulfill timed posts.
2700     $timelimit = '';
2701     if (!empty($CFG->forum_enabletimedposts)) {
2702         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2703             $timelimit = ' AND ((d.timestart <= :tltimestart AND (d.timeend = 0 OR d.timeend > :tltimeend))';
2704             $params['tltimestart'] = $now;
2705             $params['tltimeend'] = $now;
2706             if (isloggedin()) {
2707                 $timelimit .= ' OR d.userid = :tluserid';
2708                 $params['tluserid'] = $USER->id;
2709             }
2710             $timelimit .= ')';
2711         }
2712     }
2714     // Limiting to posts accessible according to groups.
2715     $groupselect = '';
2716     if ($groupmode) {
2717         if ($groupmode == VISIBLEGROUPS || has_capability('moodle/site:accessallgroups', $modcontext)) {
2718             if ($currentgroup) {
2719                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2720                 $params['groupid'] = $currentgroup;
2721             }
2722         } else {
2723             if ($currentgroup) {
2724                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2725                 $params['groupid'] = $currentgroup;
2726             } else {
2727                 $groupselect = 'AND d.groupid = -1';
2728             }
2729         }
2730     }
2732     $params['forumid'] = $cm->instance;
2733     $params['discid'] = $discussion->id;
2734     $params['disctimemodified'] = $discussion->timemodified;
2736     $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
2737               FROM {forum_discussions} d
2738              WHERE d.forum = :forumid
2739                AND d.id <> :discid
2740                    $timelimit
2741                    $groupselect";
2743     $prevsql = $sql . " AND d.timemodified < :disctimemodified
2744                    ORDER BY d.timemodified DESC";
2746     $nextsql = $sql . " AND d.timemodified > :disctimemodified
2747                    ORDER BY d.timemodified ASC";
2749     $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
2750     $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
2752     return $neighbours;
2755 /**
2756  *
2757  * @global object
2758  * @global object
2759  * @global object
2760  * @uses CONTEXT_MODULE
2761  * @uses VISIBLEGROUPS
2762  * @param object $cm
2763  * @return array
2764  */
2765 function forum_get_discussions_unread($cm) {
2766     global $CFG, $DB, $USER;
2768     $now = round(time(), -2);
2769     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2771     $params = array();
2772     $groupmode    = groups_get_activity_groupmode($cm);
2773     $currentgroup = groups_get_activity_group($cm);
2775     if ($groupmode) {
2776         $modcontext = context_module::instance($cm->id);
2778         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2779             if ($currentgroup) {
2780                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2781                 $params['currentgroup'] = $currentgroup;
2782             } else {
2783                 $groupselect = "";
2784             }
2786         } else {
2787             //separate groups without access all
2788             if ($currentgroup) {
2789                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2790                 $params['currentgroup'] = $currentgroup;
2791             } else {
2792                 $groupselect = "AND d.groupid = -1";
2793             }
2794         }
2795     } else {
2796         $groupselect = "";
2797     }
2799     if (!empty($CFG->forum_enabletimedposts)) {
2800         $timedsql = "AND d.timestart < :now1 AND (d.timeend = 0 OR d.timeend > :now2)";
2801         $params['now1'] = $now;
2802         $params['now2'] = $now;
2803     } else {
2804         $timedsql = "";
2805     }
2807     $sql = "SELECT d.id, COUNT(p.id) AS unread
2808               FROM {forum_discussions} d
2809                    JOIN {forum_posts} p     ON p.discussion = d.id
2810                    LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = $USER->id)
2811              WHERE d.forum = {$cm->instance}
2812                    AND p.modified >= :cutoffdate AND r.id is NULL
2813                    $groupselect
2814                    $timedsql
2815           GROUP BY d.id";
2816     $params['cutoffdate'] = $cutoffdate;
2818     if ($unreads = $DB->get_records_sql($sql, $params)) {
2819         foreach ($unreads as $unread) {
2820             $unreads[$unread->id] = $unread->unread;
2821         }
2822         return $unreads;
2823     } else {
2824         return array();
2825     }
2828 /**
2829  * @global object
2830  * @global object
2831  * @global object
2832  * @uses CONEXT_MODULE
2833  * @uses VISIBLEGROUPS
2834  * @param object $cm
2835  * @return array
2836  */
2837 function forum_get_discussions_count($cm) {
2838     global $CFG, $DB, $USER;
2840     $now = round(time(), -2);
2841     $params = array($cm->instance);
2842     $groupmode    = groups_get_activity_groupmode($cm);
2843     $currentgroup = groups_get_activity_group($cm);
2845     if ($groupmode) {
2846         $modcontext = context_module::instance($cm->id);
2848         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2849             if ($currentgroup) {
2850                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2851                 $params[] = $currentgroup;
2852             } else {
2853                 $groupselect = "";
2854             }
2856         } else {
2857             //seprate groups without access all
2858             if ($currentgroup) {
2859                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2860                 $params[] = $currentgroup;
2861             } else {
2862                 $groupselect = "AND d.groupid = -1";
2863             }
2864         }
2865     } else {
2866         $groupselect = "";
2867     }
2869     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2871     $timelimit = "";
2873     if (!empty($CFG->forum_enabletimedposts)) {
2875         $modcontext = context_module::instance($cm->id);
2877         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2878             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2879             $params[] = $now;
2880             $params[] = $now;
2881             if (isloggedin()) {
2882                 $timelimit .= " OR d.userid = ?";
2883                 $params[] = $USER->id;
2884             }
2885             $timelimit .= ")";
2886         }
2887     }
2889     $sql = "SELECT COUNT(d.id)
2890               FROM {forum_discussions} d
2891                    JOIN {forum_posts} p ON p.discussion = d.id
2892              WHERE d.forum = ? AND p.parent = 0
2893                    $groupselect $timelimit";
2895     return $DB->get_field_sql($sql, $params);
2899 // OTHER FUNCTIONS ///////////////////////////////////////////////////////////
2902 /**
2903  * @global object
2904  * @global object
2905  * @param int $courseid
2906  * @param string $type
2907  */
2908 function forum_get_course_forum($courseid, $type) {
2909 // How to set up special 1-per-course forums
2910     global $CFG, $DB, $OUTPUT, $USER;
2912     if ($forums = $DB->get_records_select("forum", "course = ? AND type = ?", array($courseid, $type), "id ASC")) {
2913         // There should always only be ONE, but with the right combination of
2914         // errors there might be more.  In this case, just return the oldest one (lowest ID).
2915         foreach ($forums as $forum) {
2916             return $forum;   // ie the first one
2917         }
2918     }
2920     // Doesn't exist, so create one now.
2921     $forum = new stdClass();
2922     $forum->course = $courseid;
2923     $forum->type = "$type";
2924     if (!empty($USER->htmleditor)) {
2925         $forum->introformat = $USER->htmleditor;
2926     }
2927     switch ($forum->type) {
2928         case "news":
2929             $forum->name  = get_string("namenews", "forum");
2930             $forum->intro = get_string("intronews", "forum");
2931             $forum->forcesubscribe = FORUM_FORCESUBSCRIBE;
2932             $forum->assessed = 0;
2933             if ($courseid == SITEID) {
2934                 $forum->name  = get_string("sitenews");
2935                 $forum->forcesubscribe = 0;
2936             }
2937             break;
2938         case "social":
2939             $forum->name  = get_string("namesocial", "forum");
2940             $forum->intro = get_string("introsocial", "forum");
2941             $forum->assessed = 0;
2942             $forum->forcesubscribe = 0;
2943             break;
2944         case "blog":
2945             $forum->name = get_string('blogforum', 'forum');
2946             $forum->intro = get_string('introblog', 'forum');
2947             $forum->assessed = 0;
2948             $forum->forcesubscribe = 0;
2949             break;
2950         default:
2951             echo $OUTPUT->notification("That forum type doesn't exist!");
2952             return false;
2953             break;
2954     }
2956     $forum->timemodified = time();
2957     $forum->id = $DB->insert_record("forum", $forum);
2959     if (! $module = $DB->get_record("modules", array("name" => "forum"))) {
2960         echo $OUTPUT->notification("Could not find forum module!!");
2961         return false;
2962     }
2963     $mod = new stdClass();
2964     $mod->course = $courseid;
2965     $mod->module = $module->id;
2966     $mod->instance = $forum->id;
2967     $mod->section = 0;
2968     include_once("$CFG->dirroot/course/lib.php");
2969     if (! $mod->coursemodule = add_course_module($mod) ) {
2970         echo $OUTPUT->notification("Could not add a new course module to the course '" . $courseid . "'");
2971         return false;
2972     }
2973     $sectionid = course_add_cm_to_section($courseid, $mod->coursemodule, 0);
2974     return $DB->get_record("forum", array("id" => "$forum->id"));
2978 /**
2979  * Given the data about a posting, builds up the HTML to display it and
2980  * returns the HTML in a string.  This is designed for sending via HTML email.
2981  *
2982  * @global object
2983  * @param object $course
2984  * @param object $cm
2985  * @param object $forum
2986  * @param object $discussion
2987  * @param object $post
2988  * @param object $userform
2989  * @param object $userto
2990  * @param bool $ownpost
2991  * @param bool $reply
2992  * @param bool $link
2993  * @param bool $rate
2994  * @param string $footer
2995  * @return string
2996  */
2997 function forum_make_mail_post($course, $cm, $forum, $discussion, $post, $userfrom, $userto,
2998                               $ownpost=false, $reply=false, $link=false, $rate=false, $footer="") {
3000     global $CFG, $OUTPUT;
3002     $modcontext = context_module::instance($cm->id);
3004     if (!isset($userto->viewfullnames[$forum->id])) {
3005         $viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
3006     } else {
3007         $viewfullnames = $userto->viewfullnames[$forum->id];
3008     }
3010     // add absolute file links
3011     $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
3013     // format the post body
3014     $options = new stdClass();
3015     $options->para = true;
3016     $formattedtext = format_text($post->message, $post->messageformat, $options, $course->id);
3018     $output = '<table border="0" cellpadding="3" cellspacing="0" class="forumpost">';
3020     $output .= '<tr class="header"><td width="35" valign="top" class="picture left">';
3021     $output .= $OUTPUT->user_picture($userfrom, array('courseid'=>$course->id));
3022     $output .= '</td>';
3024     if ($post->parent) {
3025         $output .= '<td class="topic">';
3026     } else {
3027         $output .= '<td class="topic starter">';
3028     }
3029     $output .= '<div class="subject">'.format_string($post->subject).'</div>';
3031     $fullname = fullname($userfrom, $viewfullnames);
3032     $by = new stdClass();
3033     $by->name = '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$userfrom->id.'&amp;course='.$course->id.'">'.$fullname.'</a>';
3034     $by->date = userdate($post->modified, '', $userto->timezone);
3035     $output .= '<div class="author">'.get_string('bynameondate', 'forum', $by).'</div>';
3037     $output .= '</td></tr>';
3039     $output .= '<tr><td class="left side" valign="top">';
3041     if (isset($userfrom->groups)) {
3042         $groups = $userfrom->groups[$forum->id];
3043     } else {
3044         $groups = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
3045     }
3047     if ($groups) {
3048         $output .= print_group_picture($groups, $course->id, false, true, true);
3049     } else {
3050         $output .= '&nbsp;';
3051     }
3053     $output .= '</td><td class="content">';
3055     $attachments = forum_print_attachments($post, $cm, 'html');
3056     if ($attachments !== '') {
3057         $output .= '<div class="attachments">';
3058         $output .= $attachments;
3059         $output .= '</div>';
3060     }
3062     $output .= $formattedtext;
3064 // Commands
3065     $commands = array();
3067     if ($post->parent) {
3068         $commands[] = '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.
3069                       $post->discussion.'&amp;parent='.$post->parent.'">'.get_string('parent', 'forum').'</a>';
3070     }
3072     if ($reply) {
3073         $commands[] = '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/post.php?reply='.$post->id.'">'.
3074                       get_string('reply', 'forum').'</a>';
3075     }
3077     $output .= '<div class="commands">';
3078     $output .= implode(' | ', $commands);
3079     $output .= '</div>';
3081 // Context link to post if required
3082     if ($link) {
3083         $output .= '<div class="link">';
3084         $output .= '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'#p'.$post->id.'">'.
3085                      get_string('postincontext', 'forum').'</a>';
3086         $output .= '</div>';
3087     }
3089     if ($footer) {
3090         $output .= '<div class="footer">'.$footer.'</div>';
3091     }
3092     $output .= '</td></tr></table>'."\n\n";
3094     return $output;
3097 /**
3098  * Print a forum post
3099  *
3100  * @global object
3101  * @global object
3102  * @uses FORUM_MODE_THREADED
3103  * @uses PORTFOLIO_FORMAT_PLAINHTML
3104  * @uses PORTFOLIO_FORMAT_FILE
3105  * @uses PORTFOLIO_FORMAT_RICHHTML
3106  * @uses PORTFOLIO_ADD_TEXT_LINK
3107  * @uses CONTEXT_MODULE
3108  * @param object $post The post to print.
3109  * @param object $discussion
3110  * @param object $forum
3111  * @param object $cm
3112  * @param object $course
3113  * @param boolean $ownpost Whether this post belongs to the current user.
3114  * @param boolean $reply Whether to print a 'reply' link at the bottom of the message.
3115  * @param boolean $link Just print a shortened version of the post as a link to the full post.
3116  * @param string $footer Extra stuff to print after the message.
3117  * @param string $highlight Space-separated list of terms to highlight.
3118  * @param int $post_read true, false or -99. If we already know whether this user
3119  *          has read this post, pass that in, otherwise, pass in -99, and this
3120  *          function will work it out.
3121  * @param boolean $dummyifcantsee When forum_user_can_see_post says that
3122  *          the current user can't see this post, if this argument is true
3123  *          (the default) then print a dummy 'you can't see this post' post.
3124  *          If false, don't output anything at all.
3125  * @param bool|null $istracked
3126  * @return void
3127  */
3128 function forum_print_post($post, $discussion, $forum, &$cm, $course, $ownpost=false, $reply=false, $link=false,
3129                           $footer="", $highlight="", $postisread=null, $dummyifcantsee=true, $istracked=null, $return=false) {
3130     global $USER, $CFG, $OUTPUT;
3132     require_once($CFG->libdir . '/filelib.php');
3134     // String cache
3135     static $str;
3137     $modcontext = context_module::instance($cm->id);
3139     $post->course = $course->id;
3140     $post->forum  = $forum->id;
3141     $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
3142     if (!empty($CFG->enableplagiarism)) {
3143         require_once($CFG->libdir.'/plagiarismlib.php');
3144         $post->message .= plagiarism_get_links(array('userid' => $post->userid,
3145             'content' => $post->message,
3146             'cmid' => $cm->id,
3147             'course' => $post->course,
3148             'forum' => $post->forum));
3149     }
3151     // caching
3152     if (!isset($cm->cache)) {
3153         $cm->cache = new stdClass;
3154     }
3156     if (!isset($cm->cache->caps)) {
3157         $cm->cache->caps = array();
3158         $cm->cache->caps['mod/forum:viewdiscussion']   = has_capability('mod/forum:viewdiscussion', $modcontext);
3159         $cm->cache->caps['moodle/site:viewfullnames']  = has_capability('moodle/site:viewfullnames', $modcontext);
3160         $cm->cache->caps['mod/forum:editanypost']      = has_capability('mod/forum:editanypost', $modcontext);
3161         $cm->cache->caps['mod/forum:splitdiscussions'] = has_capability('mod/forum:splitdiscussions', $modcontext);
3162         $cm->cache->caps['mod/forum:deleteownpost']    = has_capability('mod/forum:deleteownpost', $modcontext);
3163         $cm->cache->caps['mod/forum:deleteanypost']    = has_capability('mod/forum:deleteanypost', $modcontext);
3164         $cm->cache->caps['mod/forum:viewanyrating']    = has_capability('mod/forum:viewanyrating', $modcontext);
3165         $cm->cache->caps['mod/forum:exportpost']       = has_capability('mod/forum:exportpost', $modcontext);
3166         $cm->cache->caps['mod/forum:exportownpost']    = has_capability('mod/forum:exportownpost', $modcontext);
3167     }
3169     if (!isset($cm->uservisible)) {
3170         $cm->uservisible = \core_availability\info_module::is_user_visible($cm, 0, false);
3171     }
3173     if ($istracked && is_null($postisread)) {
3174         $postisread = forum_tp_is_post_read($USER->id, $post);
3175     }
3177     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
3178         $output = '';
3179         if (!$dummyifcantsee) {
3180             if ($return) {
3181                 return $output;
3182             }
3183             echo $output;
3184             return;
3185         }
3186         $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3187         $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix',
3188                                                        'role' => 'region',
3189                                                        'aria-label' => get_string('hiddenforumpost', 'forum')));
3190         $output .= html_writer::start_tag('div', array('class'=>'row header'));
3191         $output .= html_writer::tag('div', '', array('class'=>'left picture')); // Picture
3192         if ($post->parent) {
3193             $output .= html_writer::start_tag('div', array('class'=>'topic'));
3194         } else {
3195             $output .= html_writer::start_tag('div', array('class'=>'topic starter'));
3196         }
3197         $output .= html_writer::tag('div', get_string('forumsubjecthidden','forum'), array('class' => 'subject',
3198                                                                                            'role' => 'header')); // Subject.
3199         $output .= html_writer::tag('div', get_string('forumauthorhidden', 'forum'), array('class' => 'author',
3200                                                                                            'role' => 'header')); // Author.
3201         $output .= html_writer::end_tag('div');
3202         $output .= html_writer::end_tag('div'); // row
3203         $output .= html_writer::start_tag('div', array('class'=>'row'));
3204         $output .= html_writer::tag('div', '&nbsp;', array('class'=>'left side')); // Groups
3205         $output .= html_writer::tag('div', get_string('forumbodyhidden','forum'), array('class'=>'content')); // Content
3206         $output .= html_writer::end_tag('div'); // row
3207         $output .= html_writer::end_tag('div'); // forumpost
3209         if ($return) {
3210             return $output;
3211         }
3212         echo $output;
3213         return;
3214     }
3216     if (empty($str)) {
3217         $str = new stdClass;
3218         $str->edit         = get_string('edit', 'forum');
3219         $str->delete       = get_string('delete', 'forum');
3220         $str->reply        = get_string('reply', 'forum');
3221         $str->parent       = get_string('parent', 'forum');
3222         $str->pruneheading = get_string('pruneheading', 'forum');
3223         $str->prune        = get_string('prune', 'forum');
3224         $str->displaymode     = get_user_preferences('forum_displaymode', $CFG->forum_displaymode);
3225         $str->markread     = get_string('markread', 'forum');
3226         $str->markunread   = get_string('markunread', 'forum');
3227     }
3229     $discussionlink = new moodle_url('/mod/forum/discuss.php', array('d'=>$post->discussion));
3231     // Build an object that represents the posting user
3232     $postuser = new stdClass;
3233     $postuserfields = explode(',', user_picture::fields());
3234     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
3235     $postuser->id = $post->userid;
3236     $postuser->fullname    = fullname($postuser, $cm->cache->caps['moodle/site:viewfullnames']);
3237     $postuser->profilelink = new moodle_url('/user/view.php', array('id'=>$post->userid, 'course'=>$course->id));
3239     // Prepare the groups the posting user belongs to
3240     if (isset($cm->cache->usersgroups)) {
3241         $groups = array();
3242         if (isset($cm->cache->usersgroups[$post->userid])) {
3243             foreach ($cm->cache->usersgroups[$post->userid] as $gid) {
3244                 $groups[$gid] = $cm->cache->groups[$gid];
3245             }
3246         }
3247     } else {
3248         $groups = groups_get_all_groups($course->id, $post->userid, $cm->groupingid);
3249     }
3251     // Prepare the attachements for the post, files then images
3252     list($attachments, $attachedimages) = forum_print_attachments($post, $cm, 'separateimages');
3254     // Determine if we need to shorten this post
3255     $shortenpost = ($link && (strlen(strip_tags($post->message)) > $CFG->forum_longpost));
3258     // Prepare an array of commands
3259     $commands = array();
3261     // SPECIAL CASE: The front page can display a news item post to non-logged in users.
3262     // Don't display the mark read / unread controls in this case.
3263     if ($istracked && $CFG->forum_usermarksread && isloggedin()) {
3264         $url = new moodle_url($discussionlink, array('postid'=>$post->id, 'mark'=>'unread'));
3265         $text = $str->markunread;
3266         if (!$postisread) {
3267             $url->param('mark', 'read');
3268             $text = $str->markread;
3269         }
3270         if ($str->displaymode == FORUM_MODE_THREADED) {
3271             $url->param('parent', $post->parent);
3272         } else {
3273             $url->set_anchor('p'.$post->id);
3274         }
3275         $commands[] = array('url'=>$url, 'text'=>$text);
3276     }
3278     // Zoom in to the parent specifically
3279     if ($post->parent) {
3280         $url = new moodle_url($discussionlink);
3281         if ($str->displaymode == FORUM_MODE_THREADED) {
3282             $url->param('parent', $post->parent);
3283         } else {
3284             $url->set_anchor('p'.$post->parent);
3285         }
3286         $commands[] = array('url'=>$url, 'text'=>$str->parent);
3287     }
3289     // Hack for allow to edit news posts those are not displayed yet until they are displayed
3290     $age = time() - $post->created;
3291     if (!$post->parent && $forum->type == 'news' && $discussion->timestart > time()) {
3292         $age = 0;
3293     }
3295     if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3296         if (has_capability('moodle/course:manageactivities', $modcontext)) {
3297             // The first post in single simple is the forum description.
3298             $commands[] = array('url'=>new moodle_url('/course/modedit.php', array('update'=>$cm->id, 'sesskey'=>sesskey(), 'return'=>1)), 'text'=>$str->edit);
3299         }
3300     } else if (($ownpost && $age < $CFG->maxeditingtime) || $cm->cache->caps['mod/forum:editanypost']) {
3301         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('edit'=>$post->id)), 'text'=>$str->edit);
3302     }
3304     if ($cm->cache->caps['mod/forum:splitdiscussions'] && $post->parent && $forum->type != 'single') {
3305         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('prune'=>$post->id)), 'text'=>$str->prune, 'title'=>$str->pruneheading);
3306     }
3308     if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3309         // Do not allow deleting of first post in single simple type.
3310     } else if (($ownpost && $age < $CFG->maxeditingtime && $cm->cache->caps['mod/forum:deleteownpost']) || $cm->cache->caps['mod/forum:deleteanypost']) {
3311         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('delete'=>$post->id)), 'text'=>$str->delete);
3312     }
3314     if ($reply) {
3315         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php#mformforum', array('reply'=>$post->id)), 'text'=>$str->reply);
3316     }
3318     if ($CFG->enableportfolios && ($cm->cache->caps['mod/forum:exportpost'] || ($ownpost && $cm->cache->caps['mod/forum:exportownpost']))) {
3319         $p = array('postid' => $post->id);
3320         require_once($CFG->libdir.'/portfoliolib.php');
3321         $button = new portfolio_add_button();
3322         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id), 'mod_forum');
3323         if (empty($attachments)) {
3324             $button->set_formats(PORTFOLIO_FORMAT_PLAINHTML);
3325         } else {
3326             $button->set_formats(PORTFOLIO_FORMAT_RICHHTML);
3327         }
3329         $porfoliohtml = $button->to_html(PORTFOLIO_ADD_TEXT_LINK);
3330         if (!empty($porfoliohtml)) {
3331             $commands[] = $porfoliohtml;
3332         }
3333     }
3334     // Finished building commands
3337     // Begin output
3339     $output  = '';
3341     if ($istracked) {
3342         if ($postisread) {
3343             $forumpostclass = ' read';
3344         } else {
3345             $forumpostclass = ' unread';
3346             $output .= html_writer::tag('a', '', array('name'=>'unread'));
3347         }
3348     } else {
3349         // ignore trackign status if not tracked or tracked param missing
3350         $forumpostclass = '';
3351     }
3353     $topicclass = '';
3354     if (empty($post->parent)) {
3355         $topicclass = ' firstpost starter';
3356     }
3358     $postbyuser = new stdClass;
3359     $postbyuser->post = $post->subject;
3360     $postbyuser->user = $postuser->fullname;
3361     $discussionbyuser = get_string('postbyuser', 'forum', $postbyuser);
3362     $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3363     $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix'.$forumpostclass.$topicclass,
3364                                                    'role' => 'region',
3365                                                    'aria-label' => $discussionbyuser));
3366     $output .= html_writer::start_tag('div', array('class'=>'row header clearfix'));
3367     $output .= html_writer::start_tag('div', array('class'=>'left picture'));
3368     $output .= $OUTPUT->user_picture($postuser, array('courseid'=>$course->id));
3369     $output .= html_writer::end_tag('div');
3372     $output .= html_writer::start_tag('div', array('class'=>'topic'.$topicclass));
3374     $postsubject = $post->subject;
3375     if (empty($post->subjectnoformat)) {
3376         $postsubject = format_string($postsubject);
3377     }
3378     $output .= html_writer::tag('div', $postsubject, array('class'=>'subject',
3379                                                            'role' => 'heading',
3380                                                            'aria-level' => '2'));
3382     $by = new stdClass();
3383     $by->name = html_writer::link($postuser->profilelink, $postuser->fullname);
3384     $by->date = userdate($post->modified);
3385     $output .= html_writer::tag('div', get_string('bynameondate', 'forum', $by), array('class'=>'author',
3386                                                                                        'role' => 'heading',
3387                                                                                        'aria-level' => '2'));
3389     $output .= html_writer::end_tag('div'); //topic
3390     $output .= html_writer::end_tag('div'); //row
3392     $output .= html_writer::start_tag('div', array('class'=>'row maincontent clearfix'));
3393     $output .= html_writer::start_tag('div', array('class'=>'left'));
3395     $groupoutput = '';
3396     if ($groups) {
3397         $groupoutput = print_group_picture($groups, $course->id, false, true, true);
3398     }
3399     if (empty($groupoutput)) {
3400         $groupoutput = '&nbsp;';
3401     }
3402     $output .= html_writer::tag('div', $groupoutput, array('class'=>'grouppictures'));
3404     $output .= html_writer::end_tag('div'); //left side
3405     $output .= html_writer::start_tag('div', array('class'=>'no-overflow'));
3406     $output .= html_writer::start_tag('div', array('class'=>'content'));
3408     $options = new stdClass;
3409     $options->para    = false;
3410     $options->trusted = $post->messagetrust;
3411     $options->context = $modcontext;
3412     if ($shortenpost) {
3413         // Prepare shortened version by filtering the text then shortening it.
3414         $postclass    = 'shortenedpost';
3415         $postcontent  = format_text($post->message, $post->messageformat, $options);
3416         $postcontent  = shorten_text($postcontent, $CFG->forum_shortpost);
3417         $postcontent .= html_writer::link($discussionlink, get_string('readtherest', 'forum'));
3418         $postcontent .= html_writer::tag('div', '('.get_string('numwords', 'moodle', count_words($post->message)).')',
3419             array('class'=>'post-word-count'));
3420     } else {
3421         // Prepare whole post
3422         $postclass    = 'fullpost';
3423         $postcontent  = format_text($post->message, $post->messageformat, $options, $course->id);
3424         if (!empty($highlight)) {
3425             $postcontent = highlight($highlight, $postcontent);
3426         }
3427         if (!empty($forum->displaywordcount)) {
3428             $postcontent .= html_writer::tag('div', get_string('numwords', 'moodle', count_words($post->message)),
3429                 array('class'=>'post-word-count'));
3430         }
3431         $postcontent .= html_writer::tag('div', $attachedimages, array('class'=>'attachedimages'));
3432     }
3434     // Output the post content
3435     $output .= html_writer::tag('div', $postcontent, array('class'=>'posting '.$postclass));
3436     $output .= html_writer::end_tag('div'); // Content
3437     $output .= html_writer::end_tag('div'); // Content mask
3438     $output .= html_writer::end_tag('div'); // Row
3440     $output .= html_writer::start_tag('div', array('class'=>'row side'));
3441     $output .= html_writer::tag('div','&nbsp;', array('class'=>'left'));
3442     $output .= html_writer::start_tag('div', array('class'=>'options clearfix'));
3444     if (!empty($attachments)) {
3445         $output .= html_writer::tag('div', $attachments, array('class' => 'attachments'));
3446     }
3448     // Output ratings
3449     if (!empty($post->rating)) {
3450         $output .= html_writer::tag('div', $OUTPUT->render($post->rating), array('class'=>'forum-post-rating'));
3451     }
3453     // Output the commands
3454     $commandhtml = array();
3455     foreach ($commands as $command) {
3456         if (is_array($command)) {
3457             $commandhtml[] = html_writer::link($command['url'], $command['text']);
3458         } else {
3459             $commandhtml[] = $command;
3460         }
3461     }
3462     $output .= html_writer::tag('div', implode(' | ', $commandhtml), array('class'=>'commands'));
3464     // Output link to post if required
3465     if ($link && forum_user_can_post($forum, $discussion, $USER, $cm, $course, $modcontext)) {
3466         if ($post->replies == 1) {
3467             $replystring = get_string('repliesone', 'forum', $post->replies);
3468         } else {
3469             $replystring = get_string('repliesmany', 'forum', $post->replies);
3470         }
3472         $output .= html_writer::start_tag('div', array('class'=>'link'));
3473         $output .= html_writer::link($discussionlink, get_string(