05fc7017e83458e928e003bbaecba220346a44f8
[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             // Save the Inbound Message datakey here to reduce DB queries later.
548             $messageinboundgenerator->set_data($pid);
549             $messageinboundhandlers[$pid] = $messageinboundgenerator->fetch_data_key();
551             // Caching subscribed users of each forum.
552             if (!isset($subscribedusers[$forumid])) {
553                 $modcontext = context_module::instance($coursemodules[$forumid]->id);
554                 if ($subusers = \mod_forum\subscriptions::fetch_subscribed_users($forums[$forumid], 0, $modcontext, 'u.*', true)) {
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                 if ($subscriptiontime = \mod_forum\subscriptions::fetch_discussion_subscription($forum->id, $userto->id)) {
634                     // Skip posts if the user subscribed to the discussion after it was created.
635                     if (isset($subscriptiontime[$post->discussion]) && ($subscriptiontime[$post->discussion] > $post->created)) {
636                         continue;
637                     }
638                 }
640                 // Don't send email if the forum is Q&A and the user has not posted.
641                 // Initial topics are still mailed.
642                 if ($forum->type == 'qanda' && !forum_get_user_posted_time($discussion->id, $userto->id) && $pid != $discussion->firstpost) {
643                     mtrace('Did not email ' . $userto->id.' because user has not posted in discussion');
644                     continue;
645                 }
647                 // Get info about the sending user.
648                 if (array_key_exists($post->userid, $users)) {
649                     // We might know the user already.
650                     $userfrom = $users[$post->userid];
651                     if (!isset($userfrom->idnumber)) {
652                         // Minimalised user info, fetch full record.
653                         $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
654                         forum_cron_minimise_user_record($userfrom);
655                     }
657                 } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
658                     forum_cron_minimise_user_record($userfrom);
659                     // Fetch only once if possible, we can add it to user list, it will be skipped anyway.
660                     if ($userscount <= FORUM_CRON_USER_CACHE) {
661                         $userscount++;
662                         $users[$userfrom->id] = $userfrom;
663                     }
664                 } else {
665                     mtrace('Could not find user ' . $post->userid . ', author of post ' . $post->id . '. Unable to send message.');
666                     continue;
667                 }
669                 // Note: If we want to check that userto and userfrom are not the same person this is probably the spot to do it.
671                 // Setup global $COURSE properly - needed for roles and languages.
672                 cron_setup_user($userto, $course);
674                 // Fill caches.
675                 if (!isset($userto->viewfullnames[$forum->id])) {
676                     $modcontext = context_module::instance($cm->id);
677                     $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
678                 }
679                 if (!isset($userto->canpost[$discussion->id])) {
680                     $modcontext = context_module::instance($cm->id);
681                     $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
682                 }
683                 if (!isset($userfrom->groups[$forum->id])) {
684                     if (!isset($userfrom->groups)) {
685                         $userfrom->groups = array();
686                         if (isset($users[$userfrom->id])) {
687                             $users[$userfrom->id]->groups = array();
688                         }
689                     }
690                     $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
691                     if (isset($users[$userfrom->id])) {
692                         $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
693                     }
694                 }
696                 // Make sure groups allow this user to see this email.
697                 if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {
698                     // Groups are being used.
699                     if (!groups_group_exists($discussion->groupid)) {
700                         // Can't find group - be safe and don't this message.
701                         continue;
702                     }
704                     if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $modcontext)) {
705                         // Do not send posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS.
706                         continue;
707                     }
708                 }
710                 // Make sure we're allowed to see the post.
711                 if (!forum_user_can_see_post($forum, $discussion, $post, null, $cm)) {
712                     mtrace('User ' . $userto->id .' can not see ' . $post->id . '. Not sending message.');
713                     continue;
714                 }
716                 // OK so we need to send the email.
718                 // Does the user want this post in a digest?  If so postpone it for now.
719                 $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
721                 if ($maildigest > 0) {
722                     // This user wants the mails to be in digest form.
723                     $queue = new stdClass();
724                     $queue->userid       = $userto->id;
725                     $queue->discussionid = $discussion->id;
726                     $queue->postid       = $post->id;
727                     $queue->timemodified = $post->created;
728                     $DB->insert_record('forum_queue', $queue);
729                     continue;
730                 }
732                 // Prepare to actually send the post now, and build up the content.
734                 $cleanforumname = str_replace('"', "'", strip_tags(format_string($forum->name)));
736                 $userfrom->customheaders = array (
737                     // Headers to make emails easier to track.
738                     'List-Id: "'        . $cleanforumname . '" <moodleforum' . $forum->id . '@' . $hostname.'>',
739                     'List-Help: '       . $CFG->wwwroot . '/mod/forum/view.php?f=' . $forum->id,
740                     'Message-ID: '      . forum_get_email_message_id($post->id, $userto->id, $hostname),
741                     'X-Course-Id: '     . $course->id,
742                     'X-Course-Name: '   . format_string($course->fullname, true),
744                     // Headers to help prevent auto-responders.
745                     'Precedence: Bulk',
746                     'X-Auto-Response-Suppress: All',
747                     'Auto-Submitted: auto-generated',
748                 );
750                 if ($post->parent) {
751                     // This post is a reply, so add headers for threading (see MDL-22551).
752                     $userfrom->customheaders[] = 'In-Reply-To: ' . forum_get_email_message_id($post->parent, $userto->id, $hostname);
753                     $userfrom->customheaders[] = 'References: '  . forum_get_email_message_id($post->parent, $userto->id, $hostname);
754                 }
756                 $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
758                 // Generate a reply-to address from using the Inbound Message handler.
759                 $replyaddress = null;
760                 if ($userto->canpost[$discussion->id] && array_key_exists($post->id, $messageinboundhandlers)) {
761                     $messageinboundgenerator->set_data($post->id, $messageinboundhandlers[$post->id]);
762                     $replyaddress = $messageinboundgenerator->generate($userto->id);
763                 }
765                 $a = new stdClass();
766                 $a->courseshortname = $shortname;
767                 $a->forumname = $cleanforumname;
768                 $a->subject = format_string($post->subject, true);
769                 $postsubject = html_to_text(get_string('postmailsubject', 'forum', $a), 0);
770                 $posttext = forum_make_mail_text($course, $cm, $forum, $discussion, $post, $userfrom, $userto, false,
771                         $replyaddress);
772                 $posthtml = forum_make_mail_html($course, $cm, $forum, $discussion, $post, $userfrom, $userto,
773                         $replyaddress);
775                 // Send the post now!
776                 mtrace('Sending ', '');
778                 $eventdata = new \core\message\message();
779                 $eventdata->component           = 'mod_forum';
780                 $eventdata->name                = 'posts';
781                 $eventdata->userfrom            = $userfrom;
782                 $eventdata->userto              = $userto;
783                 $eventdata->subject             = $postsubject;
784                 $eventdata->fullmessage         = $posttext;
785                 $eventdata->fullmessageformat   = FORMAT_PLAIN;
786                 $eventdata->fullmessagehtml     = $posthtml;
787                 $eventdata->notification        = 1;
788                 $eventdata->replyto             = $replyaddress;
789                 if (!empty($replyaddress)) {
790                     // Add extra text to email messages if they can reply back.
791                     $textfooter = "\n\n" . get_string('replytopostbyemail', 'mod_forum');
792                     $htmlfooter = html_writer::tag('p', get_string('replytopostbyemail', 'mod_forum'));
793                     $additionalcontent = array('fullmessage' => array('footer' => $textfooter),
794                                      'fullmessagehtml' => array('footer' => $htmlfooter));
795                     $eventdata->set_additional_content('email', $additionalcontent);
796                 }
798                 // If forum_replytouser is not set then send mail using the noreplyaddress.
799                 if (empty($CFG->forum_replytouser)) {
800                     $eventdata->userfrom = core_user::get_noreply_user();
801                 }
803                 $smallmessagestrings = new stdClass();
804                 $smallmessagestrings->user          = fullname($userfrom);
805                 $smallmessagestrings->forumname     = "$shortname: " . format_string($forum->name, true) . ": " . $discussion->name;
806                 $smallmessagestrings->message       = $post->message;
808                 // Make sure strings are in message recipients language.
809                 $eventdata->smallmessage = get_string_manager()->get_string('smallmessage', 'forum', $smallmessagestrings, $userto->lang);
811                 $contexturl = new moodle_url('/mod/forum/discuss.php', array('d' => $discussion->id), 'p' . $post->id);
812                 $eventdata->contexturl = $contexturl->out();
813                 $eventdata->contexturlname = $discussion->name;
815                 $mailresult = message_send($eventdata);
816                 if (!$mailresult) {
817                     mtrace("Error: mod/forum/lib.php forum_cron(): Could not send out mail for id $post->id to user $userto->id".
818                             " ($userto->email) .. not trying again.");
819                     $errorcount[$post->id]++;
820                 } else {
821                     $mailcount[$post->id]++;
823                     // Mark post as read if forum_usermarksread is set off.
824                     if (!$CFG->forum_usermarksread) {
825                         $userto->markposts[$post->id] = $post->id;
826                     }
827                 }
829                 mtrace('post ' . $post->id . ': ' . $post->subject);
830             }
832             // Mark processed posts as read.
833             forum_tp_mark_posts_read($userto, $userto->markposts);
834             unset($userto);
835         }
836     }
838     if ($posts) {
839         foreach ($posts as $post) {
840             mtrace($mailcount[$post->id]." users were sent post $post->id, '$post->subject'");
841             if ($errorcount[$post->id]) {
842                 $DB->set_field('forum_posts', 'mailed', FORUM_MAILED_ERROR, array('id' => $post->id));
843             }
844         }
845     }
847     // release some memory
848     unset($subscribedusers);
849     unset($mailcount);
850     unset($errorcount);
852     cron_setup_user();
854     $sitetimezone = core_date::get_server_timezone();
856     // Now see if there are any digest mails waiting to be sent, and if we should send them
858     mtrace('Starting digest processing...');
860     core_php_time_limit::raise(300); // terminate if not able to fetch all digests in 5 minutes
862     if (!isset($CFG->digestmailtimelast)) {    // To catch the first time
863         set_config('digestmailtimelast', 0);
864     }
866     $timenow = time();
867     $digesttime = usergetmidnight($timenow, $sitetimezone) + ($CFG->digestmailtime * 3600);
869     // Delete any really old ones (normally there shouldn't be any)
870     $weekago = $timenow - (7 * 24 * 3600);
871     $DB->delete_records_select('forum_queue', "timemodified < ?", array($weekago));
872     mtrace ('Cleaned old digest records');
874     if ($CFG->digestmailtimelast < $digesttime and $timenow > $digesttime) {
876         mtrace('Sending forum digests: '.userdate($timenow, '', $sitetimezone));
878         $digestposts_rs = $DB->get_recordset_select('forum_queue', "timemodified < ?", array($digesttime));
880         if ($digestposts_rs->valid()) {
882             // We have work to do
883             $usermailcount = 0;
885             //caches - reuse the those filled before too
886             $discussionposts = array();
887             $userdiscussions = array();
889             foreach ($digestposts_rs as $digestpost) {
890                 if (!isset($posts[$digestpost->postid])) {
891                     if ($post = $DB->get_record('forum_posts', array('id' => $digestpost->postid))) {
892                         $posts[$digestpost->postid] = $post;
893                     } else {
894                         continue;
895                     }
896                 }
897                 $discussionid = $digestpost->discussionid;
898                 if (!isset($discussions[$discussionid])) {
899                     if ($discussion = $DB->get_record('forum_discussions', array('id' => $discussionid))) {
900                         $discussions[$discussionid] = $discussion;
901                     } else {
902                         continue;
903                     }
904                 }
905                 $forumid = $discussions[$discussionid]->forum;
906                 if (!isset($forums[$forumid])) {
907                     if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
908                         $forums[$forumid] = $forum;
909                     } else {
910                         continue;
911                     }
912                 }
914                 $courseid = $forums[$forumid]->course;
915                 if (!isset($courses[$courseid])) {
916                     if ($course = $DB->get_record('course', array('id' => $courseid))) {
917                         $courses[$courseid] = $course;
918                     } else {
919                         continue;
920                     }
921                 }
923                 if (!isset($coursemodules[$forumid])) {
924                     if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
925                         $coursemodules[$forumid] = $cm;
926                     } else {
927                         continue;
928                     }
929                 }
930                 $userdiscussions[$digestpost->userid][$digestpost->discussionid] = $digestpost->discussionid;
931                 $discussionposts[$digestpost->discussionid][$digestpost->postid] = $digestpost->postid;
932             }
933             $digestposts_rs->close(); /// Finished iteration, let's close the resultset
935             // Data collected, start sending out emails to each user
936             foreach ($userdiscussions as $userid => $thesediscussions) {
938                 core_php_time_limit::raise(120); // terminate if processing of any account takes longer than 2 minutes
940                 cron_setup_user();
942                 mtrace(get_string('processingdigest', 'forum', $userid), '... ');
944                 // First of all delete all the queue entries for this user
945                 $DB->delete_records_select('forum_queue', "userid = ? AND timemodified < ?", array($userid, $digesttime));
947                 // Init user caches - we keep the cache for one cycle only,
948                 // otherwise it would unnecessarily consume memory.
949                 if (array_key_exists($userid, $users) and isset($users[$userid]->username)) {
950                     $userto = clone($users[$userid]);
951                 } else {
952                     $userto = $DB->get_record('user', array('id' => $userid));
953                     forum_cron_minimise_user_record($userto);
954                 }
955                 $userto->viewfullnames = array();
956                 $userto->canpost       = array();
957                 $userto->markposts     = array();
959                 // Override the language and timezone of the "current" user, so that
960                 // mail is customised for the receiver.
961                 cron_setup_user($userto);
963                 $postsubject = get_string('digestmailsubject', 'forum', format_string($site->shortname, true));
965                 $headerdata = new stdClass();
966                 $headerdata->sitename = format_string($site->fullname, true);
967                 $headerdata->userprefs = $CFG->wwwroot.'/user/edit.php?id='.$userid.'&amp;course='.$site->id;
969                 $posttext = get_string('digestmailheader', 'forum', $headerdata)."\n\n";
970                 $headerdata->userprefs = '<a target="_blank" href="'.$headerdata->userprefs.'">'.get_string('digestmailprefs', 'forum').'</a>';
972                 $posthtml = "<head>";
973 /*                foreach ($CFG->stylesheets as $stylesheet) {
974                     //TODO: MDL-21120
975                     $posthtml .= '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'" />'."\n";
976                 }*/
977                 $posthtml .= "</head>\n<body id=\"email\">\n";
978                 $posthtml .= '<p>'.get_string('digestmailheader', 'forum', $headerdata).'</p><br /><hr size="1" noshade="noshade" />';
980                 foreach ($thesediscussions as $discussionid) {
982                     core_php_time_limit::raise(120);   // to be reset for each post
984                     $discussion = $discussions[$discussionid];
985                     $forum      = $forums[$discussion->forum];
986                     $course     = $courses[$forum->course];
987                     $cm         = $coursemodules[$forum->id];
989                     //override language
990                     cron_setup_user($userto, $course);
992                     // Fill caches
993                     if (!isset($userto->viewfullnames[$forum->id])) {
994                         $modcontext = context_module::instance($cm->id);
995                         $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
996                     }
997                     if (!isset($userto->canpost[$discussion->id])) {
998                         $modcontext = context_module::instance($cm->id);
999                         $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1000                     }
1002                     $strforums      = get_string('forums', 'forum');
1003                     $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
1004                     $canreply       = $userto->canpost[$discussion->id];
1005                     $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1007                     $posttext .= "\n \n";
1008                     $posttext .= '=====================================================================';
1009                     $posttext .= "\n \n";
1010                     $posttext .= "$shortname -> $strforums -> ".format_string($forum->name,true);
1011                     if ($discussion->name != $forum->name) {
1012                         $posttext  .= " -> ".format_string($discussion->name,true);
1013                     }
1014                     $posttext .= "\n";
1015                     $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1016                     $posttext .= "\n";
1018                     $posthtml .= "<p><font face=\"sans-serif\">".
1019                     "<a target=\"_blank\" href=\"$CFG->wwwroot/course/view.php?id=$course->id\">$shortname</a> -> ".
1020                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/index.php?id=$course->id\">$strforums</a> -> ".
1021                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/view.php?f=$forum->id\">".format_string($forum->name,true)."</a>";
1022                     if ($discussion->name == $forum->name) {
1023                         $posthtml .= "</font></p>";
1024                     } else {
1025                         $posthtml .= " -> <a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id\">".format_string($discussion->name,true)."</a></font></p>";
1026                     }
1027                     $posthtml .= '<p>';
1029                     $postsarray = $discussionposts[$discussionid];
1030                     sort($postsarray);
1032                     foreach ($postsarray as $postid) {
1033                         $post = $posts[$postid];
1035                         if (array_key_exists($post->userid, $users)) { // we might know him/her already
1036                             $userfrom = $users[$post->userid];
1037                             if (!isset($userfrom->idnumber)) {
1038                                 $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
1039                                 forum_cron_minimise_user_record($userfrom);
1040                             }
1042                         } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
1043                             forum_cron_minimise_user_record($userfrom);
1044                             if ($userscount <= FORUM_CRON_USER_CACHE) {
1045                                 $userscount++;
1046                                 $users[$userfrom->id] = $userfrom;
1047                             }
1049                         } else {
1050                             mtrace('Could not find user '.$post->userid);
1051                             continue;
1052                         }
1054                         if (!isset($userfrom->groups[$forum->id])) {
1055                             if (!isset($userfrom->groups)) {
1056                                 $userfrom->groups = array();
1057                                 if (isset($users[$userfrom->id])) {
1058                                     $users[$userfrom->id]->groups = array();
1059                                 }
1060                             }
1061                             $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
1062                             if (isset($users[$userfrom->id])) {
1063                                 $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
1064                             }
1065                         }
1067                         // Headers to help prevent auto-responders.
1068                         $userfrom->customheaders = array(
1069                                 "Precedence: Bulk",
1070                                 'X-Auto-Response-Suppress: All',
1071                                 'Auto-Submitted: auto-generated',
1072                             );
1074                         $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
1075                         if ($maildigest == 2) {
1076                             // Subjects and link only
1077                             $posttext .= "\n";
1078                             $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1079                             $by = new stdClass();
1080                             $by->name = fullname($userfrom);
1081                             $by->date = userdate($post->modified);
1082                             $posttext .= "\n".format_string($post->subject,true).' '.get_string("bynameondate", "forum", $by);
1083                             $posttext .= "\n---------------------------------------------------------------------";
1085                             $by->name = "<a target=\"_blank\" href=\"$CFG->wwwroot/user/view.php?id=$userfrom->id&amp;course=$course->id\">$by->name</a>";
1086                             $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>';
1088                         } else {
1089                             // The full treatment
1090                             $posttext .= forum_make_mail_text($course, $cm, $forum, $discussion, $post, $userfrom, $userto, true);
1091                             $posthtml .= forum_make_mail_post($course, $cm, $forum, $discussion, $post, $userfrom, $userto, false, $canreply, true, false);
1093                         // Create an array of postid's for this user to mark as read.
1094                             if (!$CFG->forum_usermarksread) {
1095                                 $userto->markposts[$post->id] = $post->id;
1096                             }
1097                         }
1098                     }
1099                     $footerlinks = array();
1100                     if ($canunsubscribe) {
1101                         $footerlinks[] = "<a href=\"$CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id\">" . get_string("unsubscribe", "forum") . "</a>";
1102                     } else {
1103                         $footerlinks[] = get_string("everyoneissubscribed", "forum");
1104                     }
1105                     $footerlinks[] = "<a href='{$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}'>" . get_string("digestmailpost", "forum") . '</a>';
1106                     $posthtml .= "\n<div class='mdl-right'><font size=\"1\">" . implode('&nbsp;', $footerlinks) . '</font></div>';
1107                     $posthtml .= '<hr size="1" noshade="noshade" /></p>';
1108                 }
1109                 $posthtml .= '</body>';
1111                 if (empty($userto->mailformat) || $userto->mailformat != 1) {
1112                     // This user DOESN'T want to receive HTML
1113                     $posthtml = '';
1114                 }
1116                 $attachment = $attachname='';
1117                 // Directly email forum digests rather than sending them via messaging, use the
1118                 // site shortname as 'from name', the noreply address will be used by email_to_user.
1119                 $mailresult = email_to_user($userto, $site->shortname, $postsubject, $posttext, $posthtml, $attachment, $attachname);
1121                 if (!$mailresult) {
1122                     mtrace("ERROR: mod/forum/cron.php: Could not send out digest mail to user $userto->id ".
1123                         "($userto->email)... not trying again.");
1124                 } else {
1125                     mtrace("success.");
1126                     $usermailcount++;
1128                     // Mark post as read if forum_usermarksread is set off
1129                     forum_tp_mark_posts_read($userto, $userto->markposts);
1130                 }
1131             }
1132         }
1133     /// We have finishied all digest emails, update $CFG->digestmailtimelast
1134         set_config('digestmailtimelast', $timenow);
1135     }
1137     cron_setup_user();
1139     if (!empty($usermailcount)) {
1140         mtrace(get_string('digestsentusers', 'forum', $usermailcount));
1141     }
1143     if (!empty($CFG->forum_lastreadclean)) {
1144         $timenow = time();
1145         if ($CFG->forum_lastreadclean + (24*3600) < $timenow) {
1146             set_config('forum_lastreadclean', $timenow);
1147             mtrace('Removing old forum read tracking info...');
1148             forum_tp_clean_read_records();
1149         }
1150     } else {
1151         set_config('forum_lastreadclean', time());
1152     }
1154     return true;
1157 /**
1158  * Builds and returns the body of the email notification in plain text.
1159  *
1160  * @global object
1161  * @global object
1162  * @uses CONTEXT_MODULE
1163  * @param object $course
1164  * @param object $cm
1165  * @param object $forum
1166  * @param object $discussion
1167  * @param object $post
1168  * @param object $userfrom
1169  * @param object $userto
1170  * @param boolean $bare
1171  * @param string $replyaddress The inbound address that a user can reply to the generated e-mail with. [Since 2.8].
1172  * @return string The email body in plain text format.
1173  */
1174 function forum_make_mail_text($course, $cm, $forum, $discussion, $post, $userfrom, $userto, $bare = false, $replyaddress = null) {
1175     global $CFG, $USER;
1177     $modcontext = context_module::instance($cm->id);
1179     if (!isset($userto->viewfullnames[$forum->id])) {
1180         $viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
1181     } else {
1182         $viewfullnames = $userto->viewfullnames[$forum->id];
1183     }
1185     if (!isset($userto->canpost[$discussion->id])) {
1186         $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1187     } else {
1188         $canreply = $userto->canpost[$discussion->id];
1189     }
1191     $by = New stdClass;
1192     $by->name = fullname($userfrom, $viewfullnames);
1193     $by->date = userdate($post->modified, "", core_date::get_user_timezone($userto));
1195     $strbynameondate = get_string('bynameondate', 'forum', $by);
1197     $strforums = get_string('forums', 'forum');
1199     $canunsubscribe = !\mod_forum\subscriptions::is_forcesubscribed($forum);
1201     $posttext = '';
1203     if (!$bare) {
1204         $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1205         $posttext  .= "$shortname -> $strforums -> ".format_string($forum->name,true);
1207         if ($discussion->name != $forum->name) {
1208             $posttext  .= " -> ".format_string($discussion->name,true);
1209         }
1210     }
1212     // add absolute file links
1213     $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
1215     $posttext .= "\n";
1216     $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1217     $posttext .= "\n";
1218     $posttext .= format_string($post->subject,true);
1219     if ($bare) {
1220         $posttext .= " ($CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id#p$post->id)";
1221     }
1222     $posttext .= "\n".$strbynameondate."\n";
1223     $posttext .= "---------------------------------------------------------------------\n";
1224     $posttext .= format_text_email($post->message, $post->messageformat);
1225     $posttext .= "\n\n";
1226     $posttext .= forum_print_attachments($post, $cm, "text");
1227     $posttext .= "\n---------------------------------------------------------------------\n";
1229     if (!$bare) {
1230         if ($canreply) {
1231             $posttext .= get_string("postmailinfo", "forum", $shortname)."\n";
1232             $posttext .= "$CFG->wwwroot/mod/forum/post.php?reply=$post->id\n";
1233         }
1235         if ($canunsubscribe) {
1236             if (\mod_forum\subscriptions::is_subscribed($userto->id, $forum, null, $cm)) {
1237                 // If subscribed to this forum, offer the unsubscribe link.
1238                 $posttext .= get_string("unsubscribe", "forum");
1239                 $posttext .= ": $CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id\n";
1240             }
1241             // Always offer the unsubscribe from discussion link.
1242             $posttext .= get_string("unsubscribediscussion", "forum");
1243             $posttext .= ": $CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id&d=$discussion->id\n";
1244         }
1245     }
1247     $posttext .= get_string("digestmailpost", "forum");
1248     $posttext .= ": {$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}\n";
1250     return $posttext;
1253 /**
1254  * Builds and returns the body of the email notification in html format.
1255  *
1256  * @global object
1257  * @param object $course
1258  * @param object $cm
1259  * @param object $forum
1260  * @param object $discussion
1261  * @param object $post
1262  * @param object $userfrom
1263  * @param object $userto
1264  * @param string $replyaddress The inbound address that a user can reply to the generated e-mail with. [Since 2.8].
1265  * @return string The email text in HTML format
1266  */
1267 function forum_make_mail_html($course, $cm, $forum, $discussion, $post, $userfrom, $userto, $replyaddress = null) {
1268     global $CFG;
1270     if ($userto->mailformat != 1) {  // Needs to be HTML
1271         return '';
1272     }
1274     if (!isset($userto->canpost[$discussion->id])) {
1275         $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course);
1276     } else {
1277         $canreply = $userto->canpost[$discussion->id];
1278     }
1280     $strforums = get_string('forums', 'forum');
1281     $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
1282     $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1284     $posthtml = '<head>';
1285 /*    foreach ($CFG->stylesheets as $stylesheet) {
1286         //TODO: MDL-21120
1287         $posthtml .= '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'" />'."\n";
1288     }*/
1289     $posthtml .= '</head>';
1290     $posthtml .= "\n<body id=\"email\">\n\n";
1292     $posthtml .= '<div class="navbar">'.
1293     '<a target="_blank" href="'.$CFG->wwwroot.'/course/view.php?id='.$course->id.'">'.$shortname.'</a> &raquo; '.
1294     '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/index.php?id='.$course->id.'">'.$strforums.'</a> &raquo; '.
1295     '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.format_string($forum->name,true).'</a>';
1296     if ($discussion->name == $forum->name) {
1297         $posthtml .= '</div>';
1298     } else {
1299         $posthtml .= ' &raquo; <a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id.'">'.
1300                      format_string($discussion->name,true).'</a></div>';
1301     }
1302     $posthtml .= forum_make_mail_post($course, $cm, $forum, $discussion, $post, $userfrom, $userto, false, $canreply, true, false);
1304     $footerlinks = array();
1305     if ($canunsubscribe) {
1306         if (\mod_forum\subscriptions::is_subscribed($userto->id, $forum, null, $cm)) {
1307             // If subscribed to this forum, offer the unsubscribe link.
1308             $unsublink = new moodle_url('/mod/forum/subscribe.php', array('id' => $forum->id));
1309             $footerlinks[] = html_writer::link($unsublink, get_string('unsubscribe', 'mod_forum'));
1310         }
1311         // Always offer the unsubscribe from discussion link.
1312         $unsublink = new moodle_url('/mod/forum/subscribe.php', array(
1313                 'id' => $forum->id,
1314                 'd' => $discussion->id,
1315             ));
1316         $footerlinks[] = html_writer::link($unsublink, get_string('unsubscribediscussion', 'mod_forum'));
1318         $footerlinks[] = '<a href="' . $CFG->wwwroot . '/mod/forum/unsubscribeall.php">' . get_string('unsubscribeall', 'forum') . '</a>';
1319     }
1320     $footerlinks[] = "<a href='{$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}'>" . get_string('digestmailpost', 'forum') . '</a>';
1321     $posthtml .= '<hr /><div class="mdl-align unsubscribelink">' . implode('&nbsp;', $footerlinks) . '</div>';
1323     $posthtml .= '</body>';
1325     return $posthtml;
1329 /**
1330  *
1331  * @param object $course
1332  * @param object $user
1333  * @param object $mod TODO this is not used in this function, refactor
1334  * @param object $forum
1335  * @return object A standard object with 2 variables: info (number of posts for this user) and time (last modified)
1336  */
1337 function forum_user_outline($course, $user, $mod, $forum) {
1338     global $CFG;
1339     require_once("$CFG->libdir/gradelib.php");
1340     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1341     if (empty($grades->items[0]->grades)) {
1342         $grade = false;
1343     } else {
1344         $grade = reset($grades->items[0]->grades);
1345     }
1347     $count = forum_count_user_posts($forum->id, $user->id);
1349     if ($count && $count->postcount > 0) {
1350         $result = new stdClass();
1351         $result->info = get_string("numposts", "forum", $count->postcount);
1352         $result->time = $count->lastpost;
1353         if ($grade) {
1354             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1355         }
1356         return $result;
1357     } else if ($grade) {
1358         $result = new stdClass();
1359         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1361         //datesubmitted == time created. dategraded == time modified or time overridden
1362         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1363         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1364         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1365             $result->time = $grade->dategraded;
1366         } else {
1367             $result->time = $grade->datesubmitted;
1368         }
1370         return $result;
1371     }
1372     return NULL;
1376 /**
1377  * @global object
1378  * @global object
1379  * @param object $coure
1380  * @param object $user
1381  * @param object $mod
1382  * @param object $forum
1383  */
1384 function forum_user_complete($course, $user, $mod, $forum) {
1385     global $CFG,$USER, $OUTPUT;
1386     require_once("$CFG->libdir/gradelib.php");
1388     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1389     if (!empty($grades->items[0]->grades)) {
1390         $grade = reset($grades->items[0]->grades);
1391         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1392         if ($grade->str_feedback) {
1393             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1394         }
1395     }
1397     if ($posts = forum_get_user_posts($forum->id, $user->id)) {
1399         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $course->id)) {
1400             print_error('invalidcoursemodule');
1401         }
1402         $discussions = forum_get_user_involved_discussions($forum->id, $user->id);
1404         foreach ($posts as $post) {
1405             if (!isset($discussions[$post->discussion])) {
1406                 continue;
1407             }
1408             $discussion = $discussions[$post->discussion];
1410             forum_print_post($post, $discussion, $forum, $cm, $course, false, false, false);
1411         }
1412     } else {
1413         echo "<p>".get_string("noposts", "forum")."</p>";
1414     }
1417 /**
1418  * Filters the forum discussions according to groups membership and config.
1419  *
1420  * @since  Moodle 2.8, 2.7.1, 2.6.4
1421  * @param  array $discussions Discussions with new posts array
1422  * @return array Forums with the number of new posts
1423  */
1424 function forum_filter_user_groups_discussions($discussions) {
1426     // Group the remaining discussions posts by their forumid.
1427     $filteredforums = array();
1429     // Discard not visible groups.
1430     foreach ($discussions as $discussion) {
1432         // Course data is already cached.
1433         $instances = get_fast_modinfo($discussion->course)->get_instances();
1434         $forum = $instances['forum'][$discussion->forum];
1436         // Continue if the user should not see this discussion.
1437         if (!forum_is_user_group_discussion($forum, $discussion->groupid)) {
1438             continue;
1439         }
1441         // Grouping results by forum.
1442         if (empty($filteredforums[$forum->instance])) {
1443             $filteredforums[$forum->instance] = new stdClass();
1444             $filteredforums[$forum->instance]->id = $forum->id;
1445             $filteredforums[$forum->instance]->count = 0;
1446         }
1447         $filteredforums[$forum->instance]->count += $discussion->count;
1449     }
1451     return $filteredforums;
1454 /**
1455  * Returns whether the discussion group is visible by the current user or not.
1456  *
1457  * @since Moodle 2.8, 2.7.1, 2.6.4
1458  * @param cm_info $cm The discussion course module
1459  * @param int $discussiongroupid The discussion groupid
1460  * @return bool
1461  */
1462 function forum_is_user_group_discussion(cm_info $cm, $discussiongroupid) {
1464     if ($discussiongroupid == -1 || $cm->effectivegroupmode != SEPARATEGROUPS) {
1465         return true;
1466     }
1468     if (isguestuser()) {
1469         return false;
1470     }
1472     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id)) ||
1473             in_array($discussiongroupid, $cm->get_modinfo()->get_groups($cm->groupingid))) {
1474         return true;
1475     }
1477     return false;
1480 /**
1481  * @global object
1482  * @global object
1483  * @global object
1484  * @param array $courses
1485  * @param array $htmlarray
1486  */
1487 function forum_print_overview($courses,&$htmlarray) {
1488     global $USER, $CFG, $DB, $SESSION;
1490     if (empty($courses) || !is_array($courses) || count($courses) == 0) {
1491         return array();
1492     }
1494     if (!$forums = get_all_instances_in_courses('forum',$courses)) {
1495         return;
1496     }
1498     // Courses to search for new posts
1499     $coursessqls = array();
1500     $params = array();
1501     foreach ($courses as $course) {
1503         // If the user has never entered into the course all posts are pending
1504         if ($course->lastaccess == 0) {
1505             $coursessqls[] = '(d.course = ?)';
1506             $params[] = $course->id;
1508         // Only posts created after the course last access
1509         } else {
1510             $coursessqls[] = '(d.course = ? AND p.created > ?)';
1511             $params[] = $course->id;
1512             $params[] = $course->lastaccess;
1513         }
1514     }
1515     $params[] = $USER->id;
1516     $coursessql = implode(' OR ', $coursessqls);
1518     $sql = "SELECT d.id, d.forum, d.course, d.groupid, COUNT(*) as count "
1519                 .'FROM {forum_discussions} d '
1520                 .'JOIN {forum_posts} p ON p.discussion = d.id '
1521                 ."WHERE ($coursessql) "
1522                 .'AND p.userid != ? '
1523                 .'GROUP BY d.id, d.forum, d.course, d.groupid '
1524                 .'ORDER BY d.course, d.forum';
1526     // Avoid warnings.
1527     if (!$discussions = $DB->get_records_sql($sql, $params)) {
1528         $discussions = array();
1529     }
1531     $forumsnewposts = forum_filter_user_groups_discussions($discussions);
1533     // also get all forum tracking stuff ONCE.
1534     $trackingforums = array();
1535     foreach ($forums as $forum) {
1536         if (forum_tp_can_track_forums($forum)) {
1537             $trackingforums[$forum->id] = $forum;
1538         }
1539     }
1541     if (count($trackingforums) > 0) {
1542         $cutoffdate = isset($CFG->forum_oldpostdays) ? (time() - ($CFG->forum_oldpostdays*24*60*60)) : 0;
1543         $sql = 'SELECT d.forum,d.course,COUNT(p.id) AS count '.
1544             ' FROM {forum_posts} p '.
1545             ' JOIN {forum_discussions} d ON p.discussion = d.id '.
1546             ' LEFT JOIN {forum_read} r ON r.postid = p.id AND r.userid = ? WHERE (';
1547         $params = array($USER->id);
1549         foreach ($trackingforums as $track) {
1550             $sql .= '(d.forum = ? AND (d.groupid = -1 OR d.groupid = 0 OR d.groupid = ?)) OR ';
1551             $params[] = $track->id;
1552             if (isset($SESSION->currentgroup[$track->course])) {
1553                 $groupid =  $SESSION->currentgroup[$track->course];
1554             } else {
1555                 // get first groupid
1556                 $groupids = groups_get_all_groups($track->course, $USER->id);
1557                 if ($groupids) {
1558                     reset($groupids);
1559                     $groupid = key($groupids);
1560                     $SESSION->currentgroup[$track->course] = $groupid;
1561                 } else {
1562                     $groupid = 0;
1563                 }
1564                 unset($groupids);
1565             }
1566             $params[] = $groupid;
1567         }
1568         $sql = substr($sql,0,-3); // take off the last OR
1569         $sql .= ') AND p.modified >= ? AND r.id is NULL GROUP BY d.forum,d.course';
1570         $params[] = $cutoffdate;
1572         if (!$unread = $DB->get_records_sql($sql, $params)) {
1573             $unread = array();
1574         }
1575     } else {
1576         $unread = array();
1577     }
1579     if (empty($unread) and empty($forumsnewposts)) {
1580         return;
1581     }
1583     $strforum = get_string('modulename','forum');
1585     foreach ($forums as $forum) {
1586         $str = '';
1587         $count = 0;
1588         $thisunread = 0;
1589         $showunread = false;
1590         // either we have something from logs, or trackposts, or nothing.
1591         if (array_key_exists($forum->id, $forumsnewposts) && !empty($forumsnewposts[$forum->id])) {
1592             $count = $forumsnewposts[$forum->id]->count;
1593         }
1594         if (array_key_exists($forum->id,$unread)) {
1595             $thisunread = $unread[$forum->id]->count;
1596             $showunread = true;
1597         }
1598         if ($count > 0 || $thisunread > 0) {
1599             $str .= '<div class="overview forum"><div class="name">'.$strforum.': <a title="'.$strforum.'" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.
1600                 $forum->name.'</a></div>';
1601             $str .= '<div class="info"><span class="postsincelogin">';
1602             $str .= get_string('overviewnumpostssince', 'forum', $count)."</span>";
1603             if (!empty($showunread)) {
1604                 $str .= '<div class="unreadposts">'.get_string('overviewnumunread', 'forum', $thisunread).'</div>';
1605             }
1606             $str .= '</div></div>';
1607         }
1608         if (!empty($str)) {
1609             if (!array_key_exists($forum->course,$htmlarray)) {
1610                 $htmlarray[$forum->course] = array();
1611             }
1612             if (!array_key_exists('forum',$htmlarray[$forum->course])) {
1613                 $htmlarray[$forum->course]['forum'] = ''; // initialize, avoid warnings
1614             }
1615             $htmlarray[$forum->course]['forum'] .= $str;
1616         }
1617     }
1620 /**
1621  * Given a course and a date, prints a summary of all the new
1622  * messages posted in the course since that date
1623  *
1624  * @global object
1625  * @global object
1626  * @global object
1627  * @uses CONTEXT_MODULE
1628  * @uses VISIBLEGROUPS
1629  * @param object $course
1630  * @param bool $viewfullnames capability
1631  * @param int $timestart
1632  * @return bool success
1633  */
1634 function forum_print_recent_activity($course, $viewfullnames, $timestart) {
1635     global $CFG, $USER, $DB, $OUTPUT;
1637     // do not use log table if possible, it may be huge and is expensive to join with other tables
1639     $allnamefields = user_picture::fields('u', null, 'duserid');
1640     if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
1641                                               d.timestart, d.timeend, $allnamefields
1642                                          FROM {forum_posts} p
1643                                               JOIN {forum_discussions} d ON d.id = p.discussion
1644                                               JOIN {forum} f             ON f.id = d.forum
1645                                               JOIN {user} u              ON u.id = p.userid
1646                                         WHERE p.created > ? AND f.course = ?
1647                                      ORDER BY p.id ASC", array($timestart, $course->id))) { // order by initial posting date
1648          return false;
1649     }
1651     $modinfo = get_fast_modinfo($course);
1653     $groupmodes = array();
1654     $cms    = array();
1656     $strftimerecent = get_string('strftimerecent');
1658     $printposts = array();
1659     foreach ($posts as $post) {
1660         if (!isset($modinfo->instances['forum'][$post->forum])) {
1661             // not visible
1662             continue;
1663         }
1664         $cm = $modinfo->instances['forum'][$post->forum];
1665         if (!$cm->uservisible) {
1666             continue;
1667         }
1668         $context = context_module::instance($cm->id);
1670         if (!has_capability('mod/forum:viewdiscussion', $context)) {
1671             continue;
1672         }
1674         if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
1675           and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
1676             if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1677                 continue;
1678             }
1679         }
1681         // Check that the user can see the discussion.
1682         if (forum_is_user_group_discussion($cm, $post->groupid)) {
1683             $printposts[] = $post;
1684         }
1686     }
1687     unset($posts);
1689     if (!$printposts) {
1690         return false;
1691     }
1693     echo $OUTPUT->heading(get_string('newforumposts', 'forum').':', 3);
1694     echo "\n<ul class='unlist'>\n";
1696     foreach ($printposts as $post) {
1697         $subjectclass = empty($post->parent) ? ' bold' : '';
1699         echo '<li><div class="head">'.
1700                '<div class="date">'.userdate($post->modified, $strftimerecent).'</div>'.
1701                '<div class="name">'.fullname($post, $viewfullnames).'</div>'.
1702              '</div>';
1703         echo '<div class="info'.$subjectclass.'">';
1704         if (empty($post->parent)) {
1705             echo '"<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
1706         } else {
1707             echo '"<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'&amp;parent='.$post->parent.'#p'.$post->id.'">';
1708         }
1709         $post->subject = break_up_long_words(format_string($post->subject, true));
1710         echo $post->subject;
1711         echo "</a>\"</div></li>\n";
1712     }
1714     echo "</ul>\n";
1716     return true;
1719 /**
1720  * Return grade for given user or all users.
1721  *
1722  * @global object
1723  * @global object
1724  * @param object $forum
1725  * @param int $userid optional user id, 0 means all users
1726  * @return array array of grades, false if none
1727  */
1728 function forum_get_user_grades($forum, $userid = 0) {
1729     global $CFG;
1731     require_once($CFG->dirroot.'/rating/lib.php');
1733     $ratingoptions = new stdClass;
1734     $ratingoptions->component = 'mod_forum';
1735     $ratingoptions->ratingarea = 'post';
1737     //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?
1738     $ratingoptions->modulename = 'forum';
1739     $ratingoptions->moduleid   = $forum->id;
1740     $ratingoptions->userid = $userid;
1741     $ratingoptions->aggregationmethod = $forum->assessed;
1742     $ratingoptions->scaleid = $forum->scale;
1743     $ratingoptions->itemtable = 'forum_posts';
1744     $ratingoptions->itemtableusercolumn = 'userid';
1746     $rm = new rating_manager();
1747     return $rm->get_user_grades($ratingoptions);
1750 /**
1751  * Update activity grades
1752  *
1753  * @category grade
1754  * @param object $forum
1755  * @param int $userid specific user only, 0 means all
1756  * @param boolean $nullifnone return null if grade does not exist
1757  * @return void
1758  */
1759 function forum_update_grades($forum, $userid=0, $nullifnone=true) {
1760     global $CFG, $DB;
1761     require_once($CFG->libdir.'/gradelib.php');
1763     if (!$forum->assessed) {
1764         forum_grade_item_update($forum);
1766     } else if ($grades = forum_get_user_grades($forum, $userid)) {
1767         forum_grade_item_update($forum, $grades);
1769     } else if ($userid and $nullifnone) {
1770         $grade = new stdClass();
1771         $grade->userid   = $userid;
1772         $grade->rawgrade = NULL;
1773         forum_grade_item_update($forum, $grade);
1775     } else {
1776         forum_grade_item_update($forum);
1777     }
1780 /**
1781  * Create/update grade item for given forum
1782  *
1783  * @category grade
1784  * @uses GRADE_TYPE_NONE
1785  * @uses GRADE_TYPE_VALUE
1786  * @uses GRADE_TYPE_SCALE
1787  * @param stdClass $forum Forum object with extra cmidnumber
1788  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1789  * @return int 0 if ok
1790  */
1791 function forum_grade_item_update($forum, $grades=NULL) {
1792     global $CFG;
1793     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
1794         require_once($CFG->libdir.'/gradelib.php');
1795     }
1797     $params = array('itemname'=>$forum->name, 'idnumber'=>$forum->cmidnumber);
1799     if (!$forum->assessed or $forum->scale == 0) {
1800         $params['gradetype'] = GRADE_TYPE_NONE;
1802     } else if ($forum->scale > 0) {
1803         $params['gradetype'] = GRADE_TYPE_VALUE;
1804         $params['grademax']  = $forum->scale;
1805         $params['grademin']  = 0;
1807     } else if ($forum->scale < 0) {
1808         $params['gradetype'] = GRADE_TYPE_SCALE;
1809         $params['scaleid']   = -$forum->scale;
1810     }
1812     if ($grades  === 'reset') {
1813         $params['reset'] = true;
1814         $grades = NULL;
1815     }
1817     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, $grades, $params);
1820 /**
1821  * Delete grade item for given forum
1822  *
1823  * @category grade
1824  * @param stdClass $forum Forum object
1825  * @return grade_item
1826  */
1827 function forum_grade_item_delete($forum) {
1828     global $CFG;
1829     require_once($CFG->libdir.'/gradelib.php');
1831     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, NULL, array('deleted'=>1));
1835 /**
1836  * This function returns if a scale is being used by one forum
1837  *
1838  * @global object
1839  * @param int $forumid
1840  * @param int $scaleid negative number
1841  * @return bool
1842  */
1843 function forum_scale_used ($forumid,$scaleid) {
1844     global $DB;
1845     $return = false;
1847     $rec = $DB->get_record("forum",array("id" => "$forumid","scale" => "-$scaleid"));
1849     if (!empty($rec) && !empty($scaleid)) {
1850         $return = true;
1851     }
1853     return $return;
1856 /**
1857  * Checks if scale is being used by any instance of forum
1858  *
1859  * This is used to find out if scale used anywhere
1860  *
1861  * @global object
1862  * @param $scaleid int
1863  * @return boolean True if the scale is used by any forum
1864  */
1865 function forum_scale_used_anywhere($scaleid) {
1866     global $DB;
1867     if ($scaleid and $DB->record_exists('forum', array('scale' => -$scaleid))) {
1868         return true;
1869     } else {
1870         return false;
1871     }
1874 // SQL FUNCTIONS ///////////////////////////////////////////////////////////
1876 /**
1877  * Gets a post with all info ready for forum_print_post
1878  * Most of these joins are just to get the forum id
1879  *
1880  * @global object
1881  * @global object
1882  * @param int $postid
1883  * @return mixed array of posts or false
1884  */
1885 function forum_get_post_full($postid) {
1886     global $CFG, $DB;
1888     $allnames = get_all_user_name_fields(true, 'u');
1889     return $DB->get_record_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1890                              FROM {forum_posts} p
1891                                   JOIN {forum_discussions} d ON p.discussion = d.id
1892                                   LEFT JOIN {user} u ON p.userid = u.id
1893                             WHERE p.id = ?", array($postid));
1896 /**
1897  * Gets all posts in discussion including top parent.
1898  *
1899  * @global object
1900  * @global object
1901  * @global object
1902  * @param int $discussionid
1903  * @param string $sort
1904  * @param bool $tracking does user track the forum?
1905  * @return array of posts
1906  */
1907 function forum_get_all_discussion_posts($discussionid, $sort, $tracking=false) {
1908     global $CFG, $DB, $USER;
1910     $tr_sel  = "";
1911     $tr_join = "";
1912     $params = array();
1914     if ($tracking) {
1915         $now = time();
1916         $cutoffdate = $now - ($CFG->forum_oldpostdays * 24 * 3600);
1917         $tr_sel  = ", fr.id AS postread";
1918         $tr_join = "LEFT JOIN {forum_read} fr ON (fr.postid = p.id AND fr.userid = ?)";
1919         $params[] = $USER->id;
1920     }
1922     $allnames = get_all_user_name_fields(true, 'u');
1923     $params[] = $discussionid;
1924     if (!$posts = $DB->get_records_sql("SELECT p.*, $allnames, u.email, u.picture, u.imagealt $tr_sel
1925                                      FROM {forum_posts} p
1926                                           LEFT JOIN {user} u ON p.userid = u.id
1927                                           $tr_join
1928                                     WHERE p.discussion = ?
1929                                  ORDER BY $sort", $params)) {
1930         return array();
1931     }
1933     foreach ($posts as $pid=>$p) {
1934         if ($tracking) {
1935             if (forum_tp_is_post_old($p)) {
1936                  $posts[$pid]->postread = true;
1937             }
1938         }
1939         if (!$p->parent) {
1940             continue;
1941         }
1942         if (!isset($posts[$p->parent])) {
1943             continue; // parent does not exist??
1944         }
1945         if (!isset($posts[$p->parent]->children)) {
1946             $posts[$p->parent]->children = array();
1947         }
1948         $posts[$p->parent]->children[$pid] =& $posts[$pid];
1949     }
1951     // Start with the last child of the first post.
1952     $post = &$posts[reset($posts)->id];
1954     $lastpost = false;
1955     while (!$lastpost) {
1956         if (!isset($post->children)) {
1957             $post->lastpost = true;
1958             $lastpost = true;
1959         } else {
1960              // Go to the last child of this post.
1961             $post = &$posts[end($post->children)->id];
1962         }
1963     }
1965     return $posts;
1968 /**
1969  * An array of forum objects that the user is allowed to read/search through.
1970  *
1971  * @global object
1972  * @global object
1973  * @global object
1974  * @param int $userid
1975  * @param int $courseid if 0, we look for forums throughout the whole site.
1976  * @return array of forum objects, or false if no matches
1977  *         Forum objects have the following attributes:
1978  *         id, type, course, cmid, cmvisible, cmgroupmode, accessallgroups,
1979  *         viewhiddentimedposts
1980  */
1981 function forum_get_readable_forums($userid, $courseid=0) {
1983     global $CFG, $DB, $USER;
1984     require_once($CFG->dirroot.'/course/lib.php');
1986     if (!$forummod = $DB->get_record('modules', array('name' => 'forum'))) {
1987         print_error('notinstalled', 'forum');
1988     }
1990     if ($courseid) {
1991         $courses = $DB->get_records('course', array('id' => $courseid));
1992     } else {
1993         // If no course is specified, then the user can see SITE + his courses.
1994         $courses1 = $DB->get_records('course', array('id' => SITEID));
1995         $courses2 = enrol_get_users_courses($userid, true, array('modinfo'));
1996         $courses = array_merge($courses1, $courses2);
1997     }
1998     if (!$courses) {
1999         return array();
2000     }
2002     $readableforums = array();
2004     foreach ($courses as $course) {
2006         $modinfo = get_fast_modinfo($course);
2008         if (empty($modinfo->instances['forum'])) {
2009             // hmm, no forums?
2010             continue;
2011         }
2013         $courseforums = $DB->get_records('forum', array('course' => $course->id));
2015         foreach ($modinfo->instances['forum'] as $forumid => $cm) {
2016             if (!$cm->uservisible or !isset($courseforums[$forumid])) {
2017                 continue;
2018             }
2019             $context = context_module::instance($cm->id);
2020             $forum = $courseforums[$forumid];
2021             $forum->context = $context;
2022             $forum->cm = $cm;
2024             if (!has_capability('mod/forum:viewdiscussion', $context)) {
2025                 continue;
2026             }
2028          /// group access
2029             if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
2031                 $forum->onlygroups = $modinfo->get_groups($cm->groupingid);
2032                 $forum->onlygroups[] = -1;
2033             }
2035         /// hidden timed discussions
2036             $forum->viewhiddentimedposts = true;
2037             if (!empty($CFG->forum_enabletimedposts)) {
2038                 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
2039                     $forum->viewhiddentimedposts = false;
2040                 }
2041             }
2043         /// qanda access
2044             if ($forum->type == 'qanda'
2045                     && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
2047                 // We need to check whether the user has posted in the qanda forum.
2048                 $forum->onlydiscussions = array();  // Holds discussion ids for the discussions
2049                                                     // the user is allowed to see in this forum.
2050                 if ($discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $USER->id)) {
2051                     foreach ($discussionspostedin as $d) {
2052                         $forum->onlydiscussions[] = $d->id;
2053                     }
2054                 }
2055             }
2057             $readableforums[$forum->id] = $forum;
2058         }
2060         unset($modinfo);
2062     } // End foreach $courses
2064     return $readableforums;
2067 /**
2068  * Returns a list of posts found using an array of search terms.
2069  *
2070  * @global object
2071  * @global object
2072  * @global object
2073  * @param array $searchterms array of search terms, e.g. word +word -word
2074  * @param int $courseid if 0, we search through the whole site
2075  * @param int $limitfrom
2076  * @param int $limitnum
2077  * @param int &$totalcount
2078  * @param string $extrasql
2079  * @return array|bool Array of posts found or false
2080  */
2081 function forum_search_posts($searchterms, $courseid=0, $limitfrom=0, $limitnum=50,
2082                             &$totalcount, $extrasql='') {
2083     global $CFG, $DB, $USER;
2084     require_once($CFG->libdir.'/searchlib.php');
2086     $forums = forum_get_readable_forums($USER->id, $courseid);
2088     if (count($forums) == 0) {
2089         $totalcount = 0;
2090         return false;
2091     }
2093     $now = round(time(), -2); // db friendly
2095     $fullaccess = array();
2096     $where = array();
2097     $params = array();
2099     foreach ($forums as $forumid => $forum) {
2100         $select = array();
2102         if (!$forum->viewhiddentimedposts) {
2103             $select[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
2104             $params = array_merge($params, array('userid'.$forumid=>$USER->id, 'timestart'.$forumid=>$now, 'timeend'.$forumid=>$now));
2105         }
2107         $cm = $forum->cm;
2108         $context = $forum->context;
2110         if ($forum->type == 'qanda'
2111             && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
2112             if (!empty($forum->onlydiscussions)) {
2113                 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forum->onlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
2114                 $params = array_merge($params, $discussionid_params);
2115                 $select[] = "(d.id $discussionid_sql OR p.parent = 0)";
2116             } else {
2117                 $select[] = "p.parent = 0";
2118             }
2119         }
2121         if (!empty($forum->onlygroups)) {
2122             list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($forum->onlygroups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
2123             $params = array_merge($params, $groupid_params);
2124             $select[] = "d.groupid $groupid_sql";
2125         }
2127         if ($select) {
2128             $selects = implode(" AND ", $select);
2129             $where[] = "(d.forum = :forum{$forumid} AND $selects)";
2130             $params['forum'.$forumid] = $forumid;
2131         } else {
2132             $fullaccess[] = $forumid;
2133         }
2134     }
2136     if ($fullaccess) {
2137         list($fullid_sql, $fullid_params) = $DB->get_in_or_equal($fullaccess, SQL_PARAMS_NAMED, 'fula');
2138         $params = array_merge($params, $fullid_params);
2139         $where[] = "(d.forum $fullid_sql)";
2140     }
2142     $selectdiscussion = "(".implode(" OR ", $where).")";
2144     $messagesearch = '';
2145     $searchstring = '';
2147     // Need to concat these back together for parser to work.
2148     foreach($searchterms as $searchterm){
2149         if ($searchstring != '') {
2150             $searchstring .= ' ';
2151         }
2152         $searchstring .= $searchterm;
2153     }
2155     // We need to allow quoted strings for the search. The quotes *should* be stripped
2156     // by the parser, but this should be examined carefully for security implications.
2157     $searchstring = str_replace("\\\"","\"",$searchstring);
2158     $parser = new search_parser();
2159     $lexer = new search_lexer($parser);
2161     if ($lexer->parse($searchstring)) {
2162         $parsearray = $parser->get_parsed_array();
2163         list($messagesearch, $msparams) = search_generate_SQL($parsearray, 'p.message', 'p.subject',
2164                                                               'p.userid', 'u.id', 'u.firstname',
2165                                                               'u.lastname', 'p.modified', 'd.forum');
2166         $params = array_merge($params, $msparams);
2167     }
2169     $fromsql = "{forum_posts} p,
2170                   {forum_discussions} d,
2171                   {user} u";
2173     $selectsql = " $messagesearch
2174                AND p.discussion = d.id
2175                AND p.userid = u.id
2176                AND $selectdiscussion
2177                    $extrasql";
2179     $countsql = "SELECT COUNT(*)
2180                    FROM $fromsql
2181                   WHERE $selectsql";
2183     $allnames = get_all_user_name_fields(true, 'u');
2184     $searchsql = "SELECT p.*,
2185                          d.forum,
2186                          $allnames,
2187                          u.email,
2188                          u.picture,
2189                          u.imagealt
2190                     FROM $fromsql
2191                    WHERE $selectsql
2192                 ORDER BY p.modified DESC";
2194     $totalcount = $DB->count_records_sql($countsql, $params);
2196     return $DB->get_records_sql($searchsql, $params, $limitfrom, $limitnum);
2199 /**
2200  * Returns a list of all new posts that have not been mailed yet
2201  *
2202  * @param int $starttime posts created after this time
2203  * @param int $endtime posts created before this
2204  * @param int $now used for timed discussions only
2205  * @return array
2206  */
2207 function forum_get_unmailed_posts($starttime, $endtime, $now=null) {
2208     global $CFG, $DB;
2210     $params = array();
2211     $params['mailed'] = FORUM_MAILED_PENDING;
2212     $params['ptimestart'] = $starttime;
2213     $params['ptimeend'] = $endtime;
2214     $params['mailnow'] = 1;
2216     if (!empty($CFG->forum_enabletimedposts)) {
2217         if (empty($now)) {
2218             $now = time();
2219         }
2220         $timedsql = "AND (d.timestart < :dtimestart AND (d.timeend = 0 OR d.timeend > :dtimeend))";
2221         $params['dtimestart'] = $now;
2222         $params['dtimeend'] = $now;
2223     } else {
2224         $timedsql = "";
2225     }
2227     return $DB->get_records_sql("SELECT p.*, d.course, d.forum
2228                                  FROM {forum_posts} p
2229                                  JOIN {forum_discussions} d ON d.id = p.discussion
2230                                  WHERE p.mailed = :mailed
2231                                  AND p.created >= :ptimestart
2232                                  AND (p.created < :ptimeend OR p.mailnow = :mailnow)
2233                                  $timedsql
2234                                  ORDER BY p.modified ASC", $params);
2237 /**
2238  * Marks posts before a certain time as being mailed already
2239  *
2240  * @global object
2241  * @global object
2242  * @param int $endtime
2243  * @param int $now Defaults to time()
2244  * @return bool
2245  */
2246 function forum_mark_old_posts_as_mailed($endtime, $now=null) {
2247     global $CFG, $DB;
2249     if (empty($now)) {
2250         $now = time();
2251     }
2253     $params = array();
2254     $params['mailedsuccess'] = FORUM_MAILED_SUCCESS;
2255     $params['now'] = $now;
2256     $params['endtime'] = $endtime;
2257     $params['mailnow'] = 1;
2258     $params['mailedpending'] = FORUM_MAILED_PENDING;
2260     if (empty($CFG->forum_enabletimedposts)) {
2261         return $DB->execute("UPDATE {forum_posts}
2262                              SET mailed = :mailedsuccess
2263                              WHERE (created < :endtime OR mailnow = :mailnow)
2264                              AND mailed = :mailedpending", $params);
2265     } else {
2266         return $DB->execute("UPDATE {forum_posts}
2267                              SET mailed = :mailedsuccess
2268                              WHERE discussion NOT IN (SELECT d.id
2269                                                       FROM {forum_discussions} d
2270                                                       WHERE d.timestart > :now)
2271                              AND (created < :endtime OR mailnow = :mailnow)
2272                              AND mailed = :mailedpending", $params);
2273     }
2276 /**
2277  * Get all the posts for a user in a forum suitable for forum_print_post
2278  *
2279  * @global object
2280  * @global object
2281  * @uses CONTEXT_MODULE
2282  * @return array
2283  */
2284 function forum_get_user_posts($forumid, $userid) {
2285     global $CFG, $DB;
2287     $timedsql = "";
2288     $params = array($forumid, $userid);
2290     if (!empty($CFG->forum_enabletimedposts)) {
2291         $cm = get_coursemodule_from_instance('forum', $forumid);
2292         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2293             $now = time();
2294             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2295             $params[] = $now;
2296             $params[] = $now;
2297         }
2298     }
2300     $allnames = get_all_user_name_fields(true, 'u');
2301     return $DB->get_records_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
2302                               FROM {forum} f
2303                                    JOIN {forum_discussions} d ON d.forum = f.id
2304                                    JOIN {forum_posts} p       ON p.discussion = d.id
2305                                    JOIN {user} u              ON u.id = p.userid
2306                              WHERE f.id = ?
2307                                    AND p.userid = ?
2308                                    $timedsql
2309                           ORDER BY p.modified ASC", $params);
2312 /**
2313  * Get all the discussions user participated in
2314  *
2315  * @global object
2316  * @global object
2317  * @uses CONTEXT_MODULE
2318  * @param int $forumid
2319  * @param int $userid
2320  * @return array Array or false
2321  */
2322 function forum_get_user_involved_discussions($forumid, $userid) {
2323     global $CFG, $DB;
2325     $timedsql = "";
2326     $params = array($forumid, $userid);
2327     if (!empty($CFG->forum_enabletimedposts)) {
2328         $cm = get_coursemodule_from_instance('forum', $forumid);
2329         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2330             $now = time();
2331             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2332             $params[] = $now;
2333             $params[] = $now;
2334         }
2335     }
2337     return $DB->get_records_sql("SELECT DISTINCT d.*
2338                               FROM {forum} f
2339                                    JOIN {forum_discussions} d ON d.forum = f.id
2340                                    JOIN {forum_posts} p       ON p.discussion = d.id
2341                              WHERE f.id = ?
2342                                    AND p.userid = ?
2343                                    $timedsql", $params);
2346 /**
2347  * Get all the posts for a user in a forum suitable for forum_print_post
2348  *
2349  * @global object
2350  * @global object
2351  * @param int $forumid
2352  * @param int $userid
2353  * @return array of counts or false
2354  */
2355 function forum_count_user_posts($forumid, $userid) {
2356     global $CFG, $DB;
2358     $timedsql = "";
2359     $params = array($forumid, $userid);
2360     if (!empty($CFG->forum_enabletimedposts)) {
2361         $cm = get_coursemodule_from_instance('forum', $forumid);
2362         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2363             $now = time();
2364             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2365             $params[] = $now;
2366             $params[] = $now;
2367         }
2368     }
2370     return $DB->get_record_sql("SELECT COUNT(p.id) AS postcount, MAX(p.modified) AS lastpost
2371                              FROM {forum} f
2372                                   JOIN {forum_discussions} d ON d.forum = f.id
2373                                   JOIN {forum_posts} p       ON p.discussion = d.id
2374                                   JOIN {user} u              ON u.id = p.userid
2375                             WHERE f.id = ?
2376                                   AND p.userid = ?
2377                                   $timedsql", $params);
2380 /**
2381  * Given a log entry, return the forum post details for it.
2382  *
2383  * @global object
2384  * @global object
2385  * @param object $log
2386  * @return array|null
2387  */
2388 function forum_get_post_from_log($log) {
2389     global $CFG, $DB;
2391     $allnames = get_all_user_name_fields(true, 'u');
2392     if ($log->action == "add post") {
2394         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2395                                  FROM {forum_discussions} d,
2396                                       {forum_posts} p,
2397                                       {forum} f,
2398                                       {user} u
2399                                 WHERE p.id = ?
2400                                   AND d.id = p.discussion
2401                                   AND p.userid = u.id
2402                                   AND u.deleted <> '1'
2403                                   AND f.id = d.forum", array($log->info));
2406     } else if ($log->action == "add discussion") {
2408         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2409                                  FROM {forum_discussions} d,
2410                                       {forum_posts} p,
2411                                       {forum} f,
2412                                       {user} u
2413                                 WHERE d.id = ?
2414                                   AND d.firstpost = p.id
2415                                   AND p.userid = u.id
2416                                   AND u.deleted <> '1'
2417                                   AND f.id = d.forum", array($log->info));
2418     }
2419     return NULL;
2422 /**
2423  * Given a discussion id, return the first post from the discussion
2424  *
2425  * @global object
2426  * @global object
2427  * @param int $dicsussionid
2428  * @return array
2429  */
2430 function forum_get_firstpost_from_discussion($discussionid) {
2431     global $CFG, $DB;
2433     return $DB->get_record_sql("SELECT p.*
2434                              FROM {forum_discussions} d,
2435                                   {forum_posts} p
2436                             WHERE d.id = ?
2437                               AND d.firstpost = p.id ", array($discussionid));
2440 /**
2441  * Returns an array of counts of replies to each discussion
2442  *
2443  * @global object
2444  * @global object
2445  * @param int $forumid
2446  * @param string $forumsort
2447  * @param int $limit
2448  * @param int $page
2449  * @param int $perpage
2450  * @return array
2451  */
2452 function forum_count_discussion_replies($forumid, $forumsort="", $limit=-1, $page=-1, $perpage=0) {
2453     global $CFG, $DB;
2455     if ($limit > 0) {
2456         $limitfrom = 0;
2457         $limitnum  = $limit;
2458     } else if ($page != -1) {
2459         $limitfrom = $page*$perpage;
2460         $limitnum  = $perpage;
2461     } else {
2462         $limitfrom = 0;
2463         $limitnum  = 0;
2464     }
2466     if ($forumsort == "") {
2467         $orderby = "";
2468         $groupby = "";
2470     } else {
2471         $orderby = "ORDER BY $forumsort";
2472         $groupby = ", ".strtolower($forumsort);
2473         $groupby = str_replace('desc', '', $groupby);
2474         $groupby = str_replace('asc', '', $groupby);
2475     }
2477     if (($limitfrom == 0 and $limitnum == 0) or $forumsort == "") {
2478         $sql = "SELECT p.discussion, COUNT(p.id) AS replies, MAX(p.id) AS lastpostid
2479                   FROM {forum_posts} p
2480                        JOIN {forum_discussions} d ON p.discussion = d.id
2481                  WHERE p.parent > 0 AND d.forum = ?
2482               GROUP BY p.discussion";
2483         return $DB->get_records_sql($sql, array($forumid));
2485     } else {
2486         $sql = "SELECT p.discussion, (COUNT(p.id) - 1) AS replies, MAX(p.id) AS lastpostid
2487                   FROM {forum_posts} p
2488                        JOIN {forum_discussions} d ON p.discussion = d.id
2489                  WHERE d.forum = ?
2490               GROUP BY p.discussion $groupby $orderby";
2491         return $DB->get_records_sql($sql, array($forumid), $limitfrom, $limitnum);
2492     }
2495 /**
2496  * @global object
2497  * @global object
2498  * @global object
2499  * @staticvar array $cache
2500  * @param object $forum
2501  * @param object $cm
2502  * @param object $course
2503  * @return mixed
2504  */
2505 function forum_count_discussions($forum, $cm, $course) {
2506     global $CFG, $DB, $USER;
2508     static $cache = array();
2510     $now = round(time(), -2); // db cache friendliness
2512     $params = array($course->id);
2514     if (!isset($cache[$course->id])) {
2515         if (!empty($CFG->forum_enabletimedposts)) {
2516             $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
2517             $params[] = $now;
2518             $params[] = $now;
2519         } else {
2520             $timedsql = "";
2521         }
2523         $sql = "SELECT f.id, COUNT(d.id) as dcount
2524                   FROM {forum} f
2525                        JOIN {forum_discussions} d ON d.forum = f.id
2526                  WHERE f.course = ?
2527                        $timedsql
2528               GROUP BY f.id";
2530         if ($counts = $DB->get_records_sql($sql, $params)) {
2531             foreach ($counts as $count) {
2532                 $counts[$count->id] = $count->dcount;
2533             }
2534             $cache[$course->id] = $counts;
2535         } else {
2536             $cache[$course->id] = array();
2537         }
2538     }
2540     if (empty($cache[$course->id][$forum->id])) {
2541         return 0;
2542     }
2544     $groupmode = groups_get_activity_groupmode($cm, $course);
2546     if ($groupmode != SEPARATEGROUPS) {
2547         return $cache[$course->id][$forum->id];
2548     }
2550     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
2551         return $cache[$course->id][$forum->id];
2552     }
2554     require_once($CFG->dirroot.'/course/lib.php');
2556     $modinfo = get_fast_modinfo($course);
2558     $mygroups = $modinfo->get_groups($cm->groupingid);
2560     // add all groups posts
2561     $mygroups[-1] = -1;
2563     list($mygroups_sql, $params) = $DB->get_in_or_equal($mygroups);
2564     $params[] = $forum->id;
2566     if (!empty($CFG->forum_enabletimedposts)) {
2567         $timedsql = "AND d.timestart < $now AND (d.timeend = 0 OR d.timeend > $now)";
2568         $params[] = $now;
2569         $params[] = $now;
2570     } else {
2571         $timedsql = "";
2572     }
2574     $sql = "SELECT COUNT(d.id)
2575               FROM {forum_discussions} d
2576              WHERE d.groupid $mygroups_sql AND d.forum = ?
2577                    $timedsql";
2579     return $DB->get_field_sql($sql, $params);
2582 /**
2583  * Get all discussions in a forum
2584  *
2585  * @global object
2586  * @global object
2587  * @global object
2588  * @uses CONTEXT_MODULE
2589  * @uses VISIBLEGROUPS
2590  * @param object $cm
2591  * @param string $forumsort
2592  * @param bool $fullpost
2593  * @param int $unused
2594  * @param int $limit
2595  * @param bool $userlastmodified
2596  * @param int $page
2597  * @param int $perpage
2598  * @return array
2599  */
2600 function forum_get_discussions($cm, $forumsort="d.timemodified DESC", $fullpost=true, $unused=-1, $limit=-1, $userlastmodified=false, $page=-1, $perpage=0) {
2601     global $CFG, $DB, $USER;
2603     $timelimit = '';
2605     $now = round(time(), -2);
2606     $params = array($cm->instance);
2608     $modcontext = context_module::instance($cm->id);
2610     if (!has_capability('mod/forum:viewdiscussion', $modcontext)) { /// User must have perms to view discussions
2611         return array();
2612     }
2614     if (!empty($CFG->forum_enabletimedposts)) { /// Users must fulfill timed posts
2616         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2617             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2618             $params[] = $now;
2619             $params[] = $now;
2620             if (isloggedin()) {
2621                 $timelimit .= " OR d.userid = ?";
2622                 $params[] = $USER->id;
2623             }
2624             $timelimit .= ")";
2625         }
2626     }
2628     if ($limit > 0) {
2629         $limitfrom = 0;
2630         $limitnum  = $limit;
2631     } else if ($page != -1) {
2632         $limitfrom = $page*$perpage;
2633         $limitnum  = $perpage;
2634     } else {
2635         $limitfrom = 0;
2636         $limitnum  = 0;
2637     }
2639     $groupmode    = groups_get_activity_groupmode($cm);
2640     $currentgroup = groups_get_activity_group($cm);
2642     if ($groupmode) {
2643         if (empty($modcontext)) {
2644             $modcontext = context_module::instance($cm->id);
2645         }
2647         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2648             if ($currentgroup) {
2649                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2650                 $params[] = $currentgroup;
2651             } else {
2652                 $groupselect = "";
2653             }
2655         } else {
2656             //seprate groups without access all
2657             if ($currentgroup) {
2658                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2659                 $params[] = $currentgroup;
2660             } else {
2661                 $groupselect = "AND d.groupid = -1";
2662             }
2663         }
2664     } else {
2665         $groupselect = "";
2666     }
2669     if (empty($forumsort)) {
2670         $forumsort = "d.timemodified DESC";
2671     }
2672     if (empty($fullpost)) {
2673         $postdata = "p.id,p.subject,p.modified,p.discussion,p.userid";
2674     } else {
2675         $postdata = "p.*";
2676     }
2678     if (empty($userlastmodified)) {  // We don't need to know this
2679         $umfields = "";
2680         $umtable  = "";
2681     } else {
2682         $umfields = ', ' . get_all_user_name_fields(true, 'um', null, 'um');
2683         $umtable  = " LEFT JOIN {user} um ON (d.usermodified = um.id)";
2684     }
2686     $allnames = get_all_user_name_fields(true, 'u');
2687     $sql = "SELECT $postdata, d.name, d.timemodified, d.usermodified, d.groupid, d.timestart, d.timeend, $allnames,
2688                    u.email, u.picture, u.imagealt $umfields
2689               FROM {forum_discussions} d
2690                    JOIN {forum_posts} p ON p.discussion = d.id
2691                    JOIN {user} u ON p.userid = u.id
2692                    $umtable
2693              WHERE d.forum = ? AND p.parent = 0
2694                    $timelimit $groupselect
2695           ORDER BY $forumsort";
2696     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
2699 /**
2700  * Gets the neighbours (previous and next) of a discussion.
2701  *
2702  * The calculation is based on the timemodified of the discussion and does not handle
2703  * the neighbours having an identical timemodified. The reason is that we do not have any
2704  * other mean to sort the records, e.g. we cannot use IDs as a greater ID can have a lower
2705  * timemodified.
2706  *
2707  * Please note that this does not check whether or not the discussion passed is accessible
2708  * by the user, it simply uses it as a reference to find the neighbours. On the other hand,
2709  * the returned neighbours are checked and are accessible to the current user.
2710  *
2711  * @param object $cm The CM record.
2712  * @param object $discussion The discussion record.
2713  * @return array That always contains the keys 'prev' and 'next'. When there is a result
2714  *               they contain the record with minimal information such as 'id' and 'name'.
2715  *               When the neighbour is not found the value is false.
2716  */
2717 function forum_get_discussion_neighbours($cm, $discussion) {
2718     global $CFG, $DB, $USER;
2720     if ($cm->instance != $discussion->forum) {
2721         throw new coding_exception('Discussion is not part of the same forum.');
2722     }
2724     $neighbours = array('prev' => false, 'next' => false);
2725     $now = round(time(), -2);
2726     $params = array();
2728     $modcontext = context_module::instance($cm->id);
2729     $groupmode    = groups_get_activity_groupmode($cm);
2730     $currentgroup = groups_get_activity_group($cm);
2732     // Users must fulfill timed posts.
2733     $timelimit = '';
2734     if (!empty($CFG->forum_enabletimedposts)) {
2735         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2736             $timelimit = ' AND ((d.timestart <= :tltimestart AND (d.timeend = 0 OR d.timeend > :tltimeend))';
2737             $params['tltimestart'] = $now;
2738             $params['tltimeend'] = $now;
2739             if (isloggedin()) {
2740                 $timelimit .= ' OR d.userid = :tluserid';
2741                 $params['tluserid'] = $USER->id;
2742             }
2743             $timelimit .= ')';
2744         }
2745     }
2747     // Limiting to posts accessible according to groups.
2748     $groupselect = '';
2749     if ($groupmode) {
2750         if ($groupmode == VISIBLEGROUPS || has_capability('moodle/site:accessallgroups', $modcontext)) {
2751             if ($currentgroup) {
2752                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2753                 $params['groupid'] = $currentgroup;
2754             }
2755         } else {
2756             if ($currentgroup) {
2757                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2758                 $params['groupid'] = $currentgroup;
2759             } else {
2760                 $groupselect = 'AND d.groupid = -1';
2761             }
2762         }
2763     }
2765     $params['forumid'] = $cm->instance;
2766     $params['discid'] = $discussion->id;
2767     $params['disctimemodified'] = $discussion->timemodified;
2769     $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
2770               FROM {forum_discussions} d
2771              WHERE d.forum = :forumid
2772                AND d.id <> :discid
2773                    $timelimit
2774                    $groupselect";
2776     $prevsql = $sql . " AND d.timemodified < :disctimemodified
2777                    ORDER BY d.timemodified DESC";
2779     $nextsql = $sql . " AND d.timemodified > :disctimemodified
2780                    ORDER BY d.timemodified ASC";
2782     $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
2783     $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
2785     return $neighbours;
2788 /**
2789  *
2790  * @global object
2791  * @global object
2792  * @global object
2793  * @uses CONTEXT_MODULE
2794  * @uses VISIBLEGROUPS
2795  * @param object $cm
2796  * @return array
2797  */
2798 function forum_get_discussions_unread($cm) {
2799     global $CFG, $DB, $USER;
2801     $now = round(time(), -2);
2802     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2804     $params = array();
2805     $groupmode    = groups_get_activity_groupmode($cm);
2806     $currentgroup = groups_get_activity_group($cm);
2808     if ($groupmode) {
2809         $modcontext = context_module::instance($cm->id);
2811         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2812             if ($currentgroup) {
2813                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2814                 $params['currentgroup'] = $currentgroup;
2815             } else {
2816                 $groupselect = "";
2817             }
2819         } else {
2820             //separate groups without access all
2821             if ($currentgroup) {
2822                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2823                 $params['currentgroup'] = $currentgroup;
2824             } else {
2825                 $groupselect = "AND d.groupid = -1";
2826             }
2827         }
2828     } else {
2829         $groupselect = "";
2830     }
2832     if (!empty($CFG->forum_enabletimedposts)) {
2833         $timedsql = "AND d.timestart < :now1 AND (d.timeend = 0 OR d.timeend > :now2)";
2834         $params['now1'] = $now;
2835         $params['now2'] = $now;
2836     } else {
2837         $timedsql = "";
2838     }
2840     $sql = "SELECT d.id, COUNT(p.id) AS unread
2841               FROM {forum_discussions} d
2842                    JOIN {forum_posts} p     ON p.discussion = d.id
2843                    LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = $USER->id)
2844              WHERE d.forum = {$cm->instance}
2845                    AND p.modified >= :cutoffdate AND r.id is NULL
2846                    $groupselect
2847                    $timedsql
2848           GROUP BY d.id";
2849     $params['cutoffdate'] = $cutoffdate;
2851     if ($unreads = $DB->get_records_sql($sql, $params)) {
2852         foreach ($unreads as $unread) {
2853             $unreads[$unread->id] = $unread->unread;
2854         }
2855         return $unreads;
2856     } else {
2857         return array();
2858     }
2861 /**
2862  * @global object
2863  * @global object
2864  * @global object
2865  * @uses CONEXT_MODULE
2866  * @uses VISIBLEGROUPS
2867  * @param object $cm
2868  * @return array
2869  */
2870 function forum_get_discussions_count($cm) {
2871     global $CFG, $DB, $USER;
2873     $now = round(time(), -2);
2874     $params = array($cm->instance);
2875     $groupmode    = groups_get_activity_groupmode($cm);
2876     $currentgroup = groups_get_activity_group($cm);
2878     if ($groupmode) {
2879         $modcontext = context_module::instance($cm->id);
2881         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2882             if ($currentgroup) {
2883                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2884                 $params[] = $currentgroup;
2885             } else {
2886                 $groupselect = "";
2887             }
2889         } else {
2890             //seprate groups without access all
2891             if ($currentgroup) {
2892                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2893                 $params[] = $currentgroup;
2894             } else {
2895                 $groupselect = "AND d.groupid = -1";
2896             }
2897         }
2898     } else {
2899         $groupselect = "";
2900     }
2902     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2904     $timelimit = "";
2906     if (!empty($CFG->forum_enabletimedposts)) {
2908         $modcontext = context_module::instance($cm->id);
2910         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2911             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2912             $params[] = $now;
2913             $params[] = $now;
2914             if (isloggedin()) {
2915                 $timelimit .= " OR d.userid = ?";
2916                 $params[] = $USER->id;
2917             }
2918             $timelimit .= ")";
2919         }
2920     }
2922     $sql = "SELECT COUNT(d.id)
2923               FROM {forum_discussions} d
2924                    JOIN {forum_posts} p ON p.discussion = d.id
2925              WHERE d.forum = ? AND p.parent = 0
2926                    $groupselect $timelimit";
2928     return $DB->get_field_sql($sql, $params);
2932 // OTHER FUNCTIONS ///////////////////////////////////////////////////////////
2935 /**
2936  * @global object
2937  * @global object
2938  * @param int $courseid
2939  * @param string $type
2940  */
2941 function forum_get_course_forum($courseid, $type) {
2942 // How to set up special 1-per-course forums
2943     global $CFG, $DB, $OUTPUT, $USER;
2945     if ($forums = $DB->get_records_select("forum", "course = ? AND type = ?", array($courseid, $type), "id ASC")) {
2946         // There should always only be ONE, but with the right combination of
2947         // errors there might be more.  In this case, just return the oldest one (lowest ID).
2948         foreach ($forums as $forum) {
2949             return $forum;   // ie the first one
2950         }
2951     }
2953     // Doesn't exist, so create one now.
2954     $forum = new stdClass();
2955     $forum->course = $courseid;
2956     $forum->type = "$type";
2957     if (!empty($USER->htmleditor)) {
2958         $forum->introformat = $USER->htmleditor;
2959     }
2960     switch ($forum->type) {
2961         case "news":
2962             $forum->name  = get_string("namenews", "forum");
2963             $forum->intro = get_string("intronews", "forum");
2964             $forum->forcesubscribe = FORUM_FORCESUBSCRIBE;
2965             $forum->assessed = 0;
2966             if ($courseid == SITEID) {
2967                 $forum->name  = get_string("sitenews");
2968                 $forum->forcesubscribe = 0;
2969             }
2970             break;
2971         case "social":
2972             $forum->name  = get_string("namesocial", "forum");
2973             $forum->intro = get_string("introsocial", "forum");
2974             $forum->assessed = 0;
2975             $forum->forcesubscribe = 0;
2976             break;
2977         case "blog":
2978             $forum->name = get_string('blogforum', 'forum');
2979             $forum->intro = get_string('introblog', 'forum');
2980             $forum->assessed = 0;
2981             $forum->forcesubscribe = 0;
2982             break;
2983         default:
2984             echo $OUTPUT->notification("That forum type doesn't exist!");
2985             return false;
2986             break;
2987     }
2989     $forum->timemodified = time();
2990     $forum->id = $DB->insert_record("forum", $forum);
2992     if (! $module = $DB->get_record("modules", array("name" => "forum"))) {
2993         echo $OUTPUT->notification("Could not find forum module!!");
2994         return false;
2995     }
2996     $mod = new stdClass();
2997     $mod->course = $courseid;
2998     $mod->module = $module->id;
2999     $mod->instance = $forum->id;
3000     $mod->section = 0;
3001     include_once("$CFG->dirroot/course/lib.php");
3002     if (! $mod->coursemodule = add_course_module($mod) ) {
3003         echo $OUTPUT->notification("Could not add a new course module to the course '" . $courseid . "'");
3004         return false;
3005     }
3006     $sectionid = course_add_cm_to_section($courseid, $mod->coursemodule, 0);
3007     return $DB->get_record("forum", array("id" => "$forum->id"));
3011 /**
3012  * Given the data about a posting, builds up the HTML to display it and
3013  * returns the HTML in a string.  This is designed for sending via HTML email.
3014  *
3015  * @global object
3016  * @param object $course
3017  * @param object $cm
3018  * @param object $forum
3019  * @param object $discussion
3020  * @param object $post
3021  * @param object $userform
3022  * @param object $userto
3023  * @param bool $ownpost
3024  * @param bool $reply
3025  * @param bool $link
3026  * @param bool $rate
3027  * @param string $footer
3028  * @return string
3029  */
3030 function forum_make_mail_post($course, $cm, $forum, $discussion, $post, $userfrom, $userto,
3031                               $ownpost=false, $reply=false, $link=false, $rate=false, $footer="") {
3033     global $CFG, $OUTPUT;
3035     $modcontext = context_module::instance($cm->id);
3037     if (!isset($userto->viewfullnames[$forum->id])) {
3038         $viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
3039     } else {
3040         $viewfullnames = $userto->viewfullnames[$forum->id];
3041     }
3043     // add absolute file links
3044     $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
3046     // format the post body
3047     $options = new stdClass();
3048     $options->para = true;
3049     $formattedtext = format_text($post->message, $post->messageformat, $options, $course->id);
3051     $output = '<table border="0" cellpadding="3" cellspacing="0" class="forumpost">';
3053     $output .= '<tr class="header"><td width="35" valign="top" class="picture left">';
3054     $output .= $OUTPUT->user_picture($userfrom, array('courseid'=>$course->id));
3055     $output .= '</td>';
3057     if ($post->parent) {
3058         $output .= '<td class="topic">';
3059     } else {
3060         $output .= '<td class="topic starter">';
3061     }
3062     $output .= '<div class="subject">'.format_string($post->subject).'</div>';
3064     $fullname = fullname($userfrom, $viewfullnames);
3065     $by = new stdClass();
3066     $by->name = '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$userfrom->id.'&amp;course='.$course->id.'">'.$fullname.'</a>';
3067     $by->date = userdate($post->modified, '', core_date::get_user_timezone($userto));
3068     $output .= '<div class="author">'.get_string('bynameondate', 'forum', $by).'</div>';
3070     $output .= '</td></tr>';
3072     $output .= '<tr><td class="left side" valign="top">';
3074     if (isset($userfrom->groups)) {
3075         $groups = $userfrom->groups[$forum->id];
3076     } else {
3077         $groups = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
3078     }
3080     if ($groups) {
3081         $output .= print_group_picture($groups, $course->id, false, true, true);
3082     } else {
3083         $output .= '&nbsp;';
3084     }
3086     $output .= '</td><td class="content">';
3088     $attachments = forum_print_attachments($post, $cm, 'html');
3089     if ($attachments !== '') {
3090         $output .= '<div class="attachments">';
3091         $output .= $attachments;
3092         $output .= '</div>';
3093     }
3095     $output .= $formattedtext;
3097 // Commands
3098     $commands = array();
3100     if ($post->parent) {
3101         $commands[] = '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.
3102                       $post->discussion.'&amp;parent='.$post->parent.'">'.get_string('parent', 'forum').'</a>';
3103     }
3105     if ($reply) {
3106         $commands[] = '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/post.php?reply='.$post->id.'">'.
3107                       get_string('reply', 'forum').'</a>';
3108     }
3110     $output .= '<div class="commands">';
3111     $output .= implode(' | ', $commands);
3112     $output .= '</div>';
3114 // Context link to post if required
3115     if ($link) {
3116         $output .= '<div class="link">';
3117         $output .= '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'#p'.$post->id.'">'.
3118                      get_string('postincontext', 'forum').'</a>';
3119         $output .= '</div>';
3120     }
3122     if ($footer) {
3123         $output .= '<div class="footer">'.$footer.'</div>';
3124     }
3125     $output .= '</td></tr></table>'."\n\n";
3127     return $output;
3130 /**
3131  * Print a forum post
3132  *
3133  * @global object
3134  * @global object
3135  * @uses FORUM_MODE_THREADED
3136  * @uses PORTFOLIO_FORMAT_PLAINHTML
3137  * @uses PORTFOLIO_FORMAT_FILE
3138  * @uses PORTFOLIO_FORMAT_RICHHTML
3139  * @uses PORTFOLIO_ADD_TEXT_LINK
3140  * @uses CONTEXT_MODULE
3141  * @param object $post The post to print.
3142  * @param object $discussion
3143  * @param object $forum
3144  * @param object $cm
3145  * @param object $course
3146  * @param boolean $ownpost Whether this post belongs to the current user.
3147  * @param boolean $reply Whether to print a 'reply' link at the bottom of the message.
3148  * @param boolean $link Just print a shortened version of the post as a link to the full post.
3149  * @param string $footer Extra stuff to print after the message.
3150  * @param string $highlight Space-separated list of terms to highlight.
3151  * @param int $post_read true, false or -99. If we already know whether this user
3152  *          has read this post, pass that in, otherwise, pass in -99, and this
3153  *          function will work it out.
3154  * @param boolean $dummyifcantsee When forum_user_can_see_post says that
3155  *          the current user can't see this post, if this argument is true
3156  *          (the default) then print a dummy 'you can't see this post' post.
3157  *          If false, don't output anything at all.
3158  * @param bool|null $istracked
3159  * @return void
3160  */
3161 function forum_print_post($post, $discussion, $forum, &$cm, $course, $ownpost=false, $reply=false, $link=false,
3162                           $footer="", $highlight="", $postisread=null, $dummyifcantsee=true, $istracked=null, $return=false) {
3163     global $USER, $CFG, $OUTPUT;
3165     require_once($CFG->libdir . '/filelib.php');
3167     // String cache
3168     static $str;
3170     $modcontext = context_module::instance($cm->id);
3172     $post->course = $course->id;
3173     $post->forum  = $forum->id;
3174     $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
3175     if (!empty($CFG->enableplagiarism)) {
3176         require_once($CFG->libdir.'/plagiarismlib.php');
3177         $post->message .= plagiarism_get_links(array('userid' => $post->userid,
3178             'content' => $post->message,
3179             'cmid' => $cm->id,
3180             'course' => $post->course,
3181             'forum' => $post->forum));
3182     }
3184     // caching
3185     if (!isset($cm->cache)) {
3186         $cm->cache = new stdClass;
3187     }
3189     if (!isset($cm->cache->caps)) {
3190         $cm->cache->caps = array();
3191         $cm->cache->caps['mod/forum:viewdiscussion']   = has_capability('mod/forum:viewdiscussion', $modcontext);
3192         $cm->cache->caps['moodle/site:viewfullnames']  = has_capability('moodle/site:viewfullnames', $modcontext);
3193         $cm->cache->caps['mod/forum:editanypost']      = has_capability('mod/forum:editanypost', $modcontext);
3194         $cm->cache->caps['mod/forum:splitdiscussions'] = has_capability('mod/forum:splitdiscussions', $modcontext);
3195         $cm->cache->caps['mod/forum:deleteownpost']    = has_capability('mod/forum:deleteownpost', $modcontext);
3196         $cm->cache->caps['mod/forum:deleteanypost']    = has_capability('mod/forum:deleteanypost', $modcontext);
3197         $cm->cache->caps['mod/forum:viewanyrating']    = has_capability('mod/forum:viewanyrating', $modcontext);
3198         $cm->cache->caps['mod/forum:exportpost']       = has_capability('mod/forum:exportpost', $modcontext);
3199         $cm->cache->caps['mod/forum:exportownpost']    = has_capability('mod/forum:exportownpost', $modcontext);
3200     }
3202     if (!isset($cm->uservisible)) {
3203         $cm->uservisible = \core_availability\info_module::is_user_visible($cm, 0, false);
3204     }
3206     if ($istracked && is_null($postisread)) {
3207         $postisread = forum_tp_is_post_read($USER->id, $post);
3208     }
3210     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
3211         $output = '';
3212         if (!$dummyifcantsee) {
3213             if ($return) {
3214                 return $output;
3215             }
3216             echo $output;
3217             return;
3218         }
3219         $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3220         $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix',
3221                                                        'role' => 'region',
3222                                                        'aria-label' => get_string('hiddenforumpost', 'forum')));
3223         $output .= html_writer::start_tag('div', array('class'=>'row header'));
3224         $output .= html_writer::tag('div', '', array('class'=>'left picture')); // Picture
3225         if ($post->parent) {
3226             $output .= html_writer::start_tag('div', array('class'=>'topic'));
3227         } else {
3228             $output .= html_writer::start_tag('div', array('class'=>'topic starter'));
3229         }
3230         $output .= html_writer::tag('div', get_string('forumsubjecthidden','forum'), array('class' => 'subject',
3231                                                                                            'role' => 'header')); // Subject.
3232         $output .= html_writer::tag('div', get_string('forumauthorhidden', 'forum'), array('class' => 'author',
3233                                                                                            'role' => 'header')); // Author.
3234         $output .= html_writer::end_tag('div');
3235         $output .= html_writer::end_tag('div'); // row
3236         $output .= html_writer::start_tag('div', array('class'=>'row'));
3237         $output .= html_writer::tag('div', '&nbsp;', array('class'=>'left side')); // Groups
3238         $output .= html_writer::tag('div', get_string('forumbodyhidden','forum'), array('class'=>'content')); // Content
3239         $output .= html_writer::end_tag('div'); // row
3240         $output .= html_writer::end_tag('div'); // forumpost
3242         if ($return) {
3243             return $output;
3244         }
3245         echo $output;
3246         return;
3247     }
3249     if (empty($str)) {
3250         $str = new stdClass;
3251         $str->edit         = get_string('edit', 'forum');
3252         $str->delete       = get_string('delete', 'forum');
3253         $str->reply        = get_string('reply', 'forum');
3254         $str->parent       = get_string('parent', 'forum');
3255         $str->pruneheading = get_string('pruneheading', 'forum');
3256         $str->prune        = get_string('prune', 'forum');
3257         $str->displaymode     = get_user_preferences('forum_displaymode', $CFG->forum_displaymode);
3258         $str->markread     = get_string('markread', 'forum');
3259         $str->markunread   = get_string('markunread', 'forum');
3260     }
3262     $discussionlink = new moodle_url('/mod/forum/discuss.php', array('d'=>$post->discussion));
3264     // Build an object that represents the posting user
3265     $postuser = new stdClass;
3266     $postuserfields = explode(',', user_picture::fields());
3267     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
3268     $postuser->id = $post->userid;
3269     $postuser->fullname    = fullname($postuser, $cm->cache->caps['moodle/site:viewfullnames']);
3270     $postuser->profilelink = new moodle_url('/user/view.php', array('id'=>$post->userid, 'course'=>$course->id));
3272     // Prepare the groups the posting user belongs to
3273     if (isset($cm->cache->usersgroups)) {
3274         $groups = array();
3275         if (isset($cm->cache->usersgroups[$post->userid])) {
3276             foreach ($cm->cache->usersgroups[$post->userid] as $gid) {
3277                 $groups[$gid] = $cm->cache->groups[$gid];
3278             }
3279         }
3280     } else {
3281         $groups = groups_get_all_groups($course->id, $post->userid, $cm->groupingid);
3282     }
3284     // Prepare the attachements for the post, files then images
3285     list($attachments, $attachedimages) = forum_print_attachments($post, $cm, 'separateimages');
3287     // Determine if we need to shorten this post
3288     $shortenpost = ($link && (strlen(strip_tags($post->message)) > $CFG->forum_longpost));
3291     // Prepare an array of commands
3292     $commands = array();
3294     // SPECIAL CASE: The front page can display a news item post to non-logged in users.
3295     // Don't display the mark read / unread controls in this case.
3296     if ($istracked && $CFG->forum_usermarksread && isloggedin()) {
3297         $url = new moodle_url($discussionlink, array('postid'=>$post->id, 'mark'=>'unread'));
3298         $text = $str->markunread;
3299         if (!$postisread) {
3300             $url->param('mark', 'read');
3301             $text = $str->markread;
3302         }
3303         if ($str->displaymode == FORUM_MODE_THREADED) {
3304             $url->param('parent', $post->parent);
3305         } else {
3306             $url->set_anchor('p'.$post->id);
3307         }
3308         $commands[] = array('url'=>$url, 'text'=>$text);
3309     }
3311     // Zoom in to the parent specifically
3312     if ($post->parent) {
3313         $url = new moodle_url($discussionlink);
3314         if ($str->displaymode == FORUM_MODE_THREADED) {
3315             $url->param('parent', $post->parent);
3316         } else {
3317             $url->set_anchor('p'.$post->parent);
3318         }
3319         $commands[] = array('url'=>$url, 'text'=>$str->parent);
3320     }
3322     // Hack for allow to edit news posts those are not displayed yet until they are displayed
3323     $age = time() - $post->created;
3324     if (!$post->parent && $forum->type == 'news' && $discussion->timestart > time()) {
3325         $age = 0;
3326     }
3328     if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3329         if (has_capability('moodle/course:manageactivities', $modcontext)) {
3330             // The first post in single simple is the forum description.
3331             $commands[] = array('url'=>new moodle_url('/course/modedit.php', array('update'=>$cm->id, 'sesskey'=>sesskey(), 'return'=>1)), 'text'=>$str->edit);
3332         }
3333     } else if (($ownpost && $age < $CFG->maxeditingtime) || $cm->cache->caps['mod/forum:editanypost']) {
3334         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('edit'=>$post->id)), 'text'=>$str->edit);
3335     }
3337     if ($cm->cache->caps['mod/forum:splitdiscussions'] && $post->parent && $forum->type != 'single') {
3338         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('prune'=>$post->id)), 'text'=>$str->prune, 'title'=>$str->pruneheading);
3339     }
3341     if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3342         // Do not allow deleting of first post in single simple type.
3343     } else if (($ownpost && $age < $CFG->maxeditingtime && $cm->cache->caps['mod/forum:deleteownpost']) || $cm->cache->caps['mod/forum:deleteanypost']) {
3344         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('delete'=>$post->id)), 'text'=>$str->delete);
3345     }
3347     if ($reply) {
3348         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php#mformforum', array('reply'=>$post->id)), 'text'=>$str->reply);
3349     }
3351     if ($CFG->enableportfolios && ($cm->cache->caps['mod/forum:exportpost'] || ($ownpost && $cm->cache->caps['mod/forum:exportownpost']))) {
3352         $p = array('postid' => $post->id);
3353         require_once($CFG->libdir.'/portfoliolib.php');
3354         $button = new portfolio_add_button();
3355         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id), 'mod_forum');
3356         if (empty($attachments)) {
3357             $button->set_formats(PORTFOLIO_FORMAT_PLAINHTML);
3358         } else {
3359             $button->set_formats(PORTFOLIO_FORMAT_RICHHTML);
3360         }
3362         $porfoliohtml = $button->to_html(PORTFOLIO_ADD_TEXT_LINK);
3363         if (!empty($porfoliohtml)) {
3364             $commands[] = $porfoliohtml;
3365         }
3366     }
3367     // Finished building commands
3370     // Begin output
3372     $output  = '';
3374     if ($istracked) {
3375         if ($postisread) {
3376             $forumpostclass = ' read';
3377         } else {
3378             $forumpostclass = ' unread';
3379             $output .= html_writer::tag('a', '', array('name'=>'unread'));
3380         }
3381     } else {
3382         // ignore trackign status if not tracked or tracked param missing
3383         $forumpostclass = '';
3384     }
3386     $topicclass = '';
3387     if (empty($post->parent)) {
3388         $topicclass = ' firstpost starter';
3389     }
3391     if (!empty($post->lastpost)) {
3392         $forumpostclass .= ' lastpost';
3393     }
3395     $postbyuser = new stdClass;
3396     $postbyuser->post = $post->subject;
3397     $postbyuser->user = $postuser->fullname;
3398     $discussionbyuser = get_string('postbyuser', 'forum', $postbyuser);
3399     $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3400     $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix'.$forumpostclass.$topicclass,
3401                                                    'role' => 'region',
3402                                                    'aria-label' => $discussionbyuser));
3403     $output .= html_writer::start_tag('div', array('class'=>'row header clearfix'));
3404     $output .= html_writer::start_tag('div', array('class'=>'left picture'));
3405     $output .= $OUTPUT->user_picture($postuser, array('courseid'=>$course->id));
3406     $output .= html_writer::end_tag('div');
3409     $output .= html_writer::start_tag('div', array('class'=>'topic'.$topicclass));
3411     $postsubject = $post->subject;
3412     if (empty($post->subjectnoformat)) {
3413         $postsubject = format_string($postsubject);
3414     }
3415     $output .= html_writer::tag('div', $postsubject, array('class'=>'subject',
3416                                                            'role' => 'heading',
3417                                                            'aria-level' => '2'));
3419     $by = new stdClass();
3420     $by->name = html_writer::link($postuser->profilelink, $postuser->fullname);
3421     $by->date = userdate($post->modified);
3422     $output .= html_writer::tag('div', get_string('bynameondate', 'forum', $by), array('class'=>'author',
3423                                                                                        'role' => 'heading',
3424                                                                                        'aria-level' => '2'));
3426     $output .= html_writer::end_tag('div'); //topic
3427     $output .= html_writer::end_tag('div'); //row
3429     $output .= html_writer::start_tag('div', array('class'=>'row maincontent clearfix'));
3430     $output .= html_writer::start_tag('div', array('class'=>'left'));
3432     $groupoutput = '';
3433     if ($groups) {
3434         $groupoutput = print_group_picture($groups, $course->id, false, true, true);
3435     }
3436     if (empty($groupoutput)) {
3437         $groupoutput = '&nbsp;';
3438     }
3439     $output .= html_writer::tag('div', $groupoutput, array('class'=>'grouppictures'));
3441     $output .= html_writer::end_tag('div'); //left side
3442     $output .= html_writer::start_tag('div', array('class'=>'no-overflow'));
3443     $output .= html_writer::start_tag('div', array('class'=>'content'));
3445     $options = new stdClass;
3446     $options->para    = false;
3447     $options->trusted = $post->messagetrust;
3448     $options->context = $modcontext;
3449     if ($shortenpost) {
3450         // Prepare shortened version by filtering the text then shortening it.
3451         $postclass    = 'shortenedpost';
3452         $postcontent  = format_text($post->message, $post->messageformat, $options);
3453         $postcontent  = shorten_text($postcontent, $CFG->forum_shortpost);
3454         $postcontent .= html_writer::link($discussionlink, get_string('readtherest', 'forum'));
3455         $postcontent .= html_writer::tag('div', '('.get_string('numwords', 'moodle', count_words($post->message)).')',
3456             array('class'=>'post-word-count'));
3457     } else {
3458         // Prepare whole post
3459         $postclass    = 'fullpost';
3460         $postcontent  = format_text($post->message, $post->messageformat, $options, $course->id);
3461         if (!empty($highlight)) {
3462             $postcontent = highlight($highlight, $postcontent);
3463         }
3464         if (!empty($forum->displaywordcount)) {
3465             $postcontent .= html_writer::tag('div', get_string('numwords', 'moodle', count_words($post->message)),
3466                 array('class'=>'post-word-count'));
3467         }
3468         $postcontent .= html_writer::tag('div', $attachedimages, array('class'=>'attachedimages'));
3469     }
3471     // Output the post content
3472     $output .= html_writer::tag('div', $postcontent, array('class'=>'posting '.$postclass));
3473     $output .= html_writer::end_tag('div'); // Content
3474     $output .= html_writer::end_tag('div'); // Content mask
3475     $output .= html_writer::end_tag('div'); // Row
3477     $output .= html_writer::start_tag('div', array('class'=>'row side'));
3478     $output .= html_writer::tag('div','&nbsp;', array('class'=>'left'));
3479     $output .= html_writer::start_tag('div', array('class'=>'options clearfix'));
3481     if (!empty($attachments)) {
3482         $output .= html_writer::tag('div', $attachments, array('class' => 'attachments'));
3483     }
3485     // Output ratings
3486     if (!empty($post->rating)) {
3487         $output .= html_writer::tag('div', $OUTPUT->render($post->rating), array('class'=>'forum-post-rating'));
3488     }
3490     // Output the commands
3491     $commandhtml = array();
3492     foreach ($commands as $command) {
3493         if (is_array($command)) {
3494             $commandhtml[] = html_writer::link($command['url'], $command['text']);
3495         } else {
3496             $commandhtml[] = $command;
3497         }
3498     }
3499     $output .= html_writer::tag('div', implode(' | ', $commandhtml), array('class'=>'commands'));
3501     // Output link to post if required
3502     if ($link && forum_user_can_post($forum, $discussion, $USER, $cm, $course, $modcontext)) {
3503         if ($post->replies == 1) {
3504             $replystring = get_string('repliesone', 'forum', $post->replies);
3505         } else {
3506             $replystring = get_string('repliesmany', 'forum', $post->replies);
3507         }
3509         $output .= html_writer::start_tag('div', array('class'=>'link'));
3510         $output .= html_writer::link($discussionlink, get_string('discussthistopic', 'forum'));
3511         $output .= '&nbsp;('.$replystring.')';
3512         $output .= html_writer::end_tag('div'); // link
3513     }
3515     // Output footer if required
3516     if ($footer) {
3517         $output .= html_writer::tag('div', $footer, array('class'=>'footer'));
3518     }
3520     // Close remaining open divs
3521     $output .= html_writer::end_tag('div'); // content
3522     $output .= html_writer::end_tag('div'); // row
3523     $output .= html_writer::end_tag('div'); // forumpost
3525     // Mark the forum post as read if required
3526     if ($istracked && !$CFG->forum_usermarksread && !$postisread) {
3527         forum_tp_mark_post_read($USER->id, $post, $forum->id);
3528     }
3530     if ($return) {
3531         return $output;
3532     }
3533     echo $output;
3534     return;
3537 /**
3538  * Return rating related permissions
3539  *
3540  * @param string $options the context id
3541  * @return array an associative array of the user's rating permissions
3542  */
3543 function forum_rating_permissions($contextid, $component, $ratingarea) {
3544     $context = context::instance_by_id($contextid, MUST_EXIST);
3545     if ($component != 'mod_forum' || $ratingarea != 'post') {
3546         // We don't know about this component/ratingarea so just return null to get the
3547         // default restrictive permissions.
3548         return null;
3549     }
3550     return array(
3551         'view'    => has_capability('mod/forum:viewrating', $context),
3552         'viewany' => has_capability('mod/forum:viewanyrating', $context),
3553         'viewall' => has_capability('mod/forum:viewallratings', $context),
3554         'rate'    => has_capability('mod/forum:rate', $context)
3555     );
3558 /**
3559  * Validates a submitted rating
3560  * @param array $params submitted data
3561  *            context => object the context in which the rated items exists [required]
3562  *            component => The component for this module - should always be mod_forum [required]
3563  *            ratingarea => object the context in which the rated items exists [required]
3564  *            itemid => int the ID of the object being rated [required]
3565  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
3566  *            rating => int the submitted rating [required]
3567  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
3568  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
3569  * @return boolean true if the rating is valid. Will throw rating_exception if not
3570  */
3571 function forum_rating_validate($params) {
3572     global $DB, $USER;
3574     // Check the component is mod_forum
3575     if ($params['component'] != 'mod_forum') {
3576         throw new rating_exception('invalidcomponent');
3577     }
3579     // Check the ratingarea is post (the only rating area in forum)
3580     if ($params['ratingarea'] != 'post') {
3581         throw new rating_exception('invalidratingarea');
3582     }
3584     // Check the rateduserid is not the current user .. you can't rate your own posts
3585     if ($params['rateduserid'] == $USER->id) {
3586         throw new rating_exception('nopermissiontorate');
3587     }
3589     // Fetch all the related records ... we need to do this anyway to call forum_user_can_see_post
3590     $post = $DB->get_record('forum_posts', array('id' => $params['itemid'], 'userid' => $params['rateduserid']), '*', MUST_EXIST);
3591     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion), '*', MUST_EXIST);
3592     $forum = $DB->get_record('forum', array('id' => $discussion->forum), '*', MUST_EXIST);
3593     $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
3594     $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id , false, MUST_EXIST);
3595     $context = context_module::instance($cm->id);
3597     // Make sure the context provided is the context of the forum
3598     if ($context->id != $params['context']->id) {
3599         throw new rating_exception('invalidcontext');
3600     }
3602     if ($forum->scale != $params['scaleid']) {
3603         //the scale being submitted doesnt match the one in the database
3604         throw new rating_exception('invalidscaleid');
3605     }
3607     // check the item we're rating was created in the assessable time window
3608     if (!empty($forum->assesstimestart) && !empty($forum->assesstimefinish)) {
3609         if ($post->created < $forum->assesstimestart || $post->created > $forum->assesstimefinish) {
3610             throw new rating_exception('notavailable');
3611         }
3612     }
3614     //check that the submitted rating is valid for the scale
3616     // lower limit
3617     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
3618         throw new rating_exception('invalidnum');
3619     }
3621     // upper limit
3622     if ($forum->scale < 0) {
3623         //its a custom scale
3624         $scalerecord = $DB->get_record('scale', array('id' => -$forum->scale));
3625         if ($scalerecord) {
3626             $scalearray = explode(',', $scalerecord->scale);
3627             if ($params['rating'] > count($scalearray)) {
3628                 throw new rating_exception('invalidnum');
3629             }
3630         } else {
3631             throw new rating_exception('invalidscaleid');
3632         }
3633     } else if ($params['rating'] > $forum->scale) {
3634         //if its numeric and submitted rating is above maximum
3635         throw new rating_exception('invalidnum');
3636     }
3638     // Make sure groups allow this user to see the item they're rating
3639     if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
3640         if (!groups_group_exists($discussion->groupid)) { // Can't find group
3641             throw new rating_exception('cannotfindgroup');//something is wrong
3642         }
3644         if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
3645             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
3646             throw new rating_exception('notmemberofgroup');
3647         }
3648     }
3650     // perform some final capability checks
3651     if (!forum_user_can_see_post($forum, $discussion, $post, $USER, $cm)) {
3652         throw new rating_exception('nopermissiontorate');
3653     }
3655     return true;
3659 /**
3660  * This function prints the overview of a discussion in the forum listing.
3661  * It needs some discussion information and some post information, these
3662  * happen to be combined for efficiency in the $post parameter by the function
3663  * that calls this one: forum_print_latest_discussions()
3664  *
3665  * @global object
3666  * @global object
3667  * @param object $post The post object (passed by reference for speed).
3668  * @param object $forum The forum object.
3669  * @param int $group Current group.
3670  * @param string $datestring Format to use for the dates.
3671  * @param boolean $cantrack Is tracking enabled for this forum.
3672  * @param boolean $forumtracked Is the user tracking this forum.
3673  * @param boolean $canviewparticipants True if user has the viewparticipants permission for this course
3674  */
3675 function forum_print_discussion_header(&$post, $forum, $group=-1, $datestring="",
3676                                         $cantrack=true, $forumtracked=true, $canviewparticipants=true, $modcontext=NULL) {
3678     global $COURSE, $USER, $CFG, $OUTPUT;
3680     static $rowcount;
3681     static $strmarkalldread;
3683     if (empty($modcontext)) {
3684         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
3685             print_error('invalidcoursemodule');
3686         }
3687         $modcontext = context_module::instance($cm->id);
3688     }
3690     if (!isset($rowcount)) {
3691         $rowcount = 0;
3692         $strmarkalldread = get_string('markalldread', 'forum');
3693     } else {
3694         $rowcount = ($rowcount + 1) % 2;
3695     }
3697     $post->subject = format_string($post->subject,true);
3699     echo "\n\n";
3700     echo '<tr class="discussion r'.$rowcount.'">';
3702     // Topic
3703     echo '<td class="topic starter">';
3704     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">'.$post->subject.'</a>';
3705     echo "</td>\n";
3707     // Picture
3708     $postuser = new stdClass();
3709     $postuserfields = explode(',', user_picture::fields());
3710     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
3711     $postuser->id = $post->userid;
3712     echo '<td class="picture">';
3713     echo $OUTPUT->user_picture($postuser, array('courseid'=>$forum->course));
3714     echo "</td>\n";
3716     // User name
3717     $fullname = fullname($postuser, has_capability('moodle/site:viewfullnames', $modcontext));
3718     echo '<td class="author">';
3719     echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->userid.'&amp;course='.$forum->course.'">'.$fullname.'</a>';
3720     echo "</td>\n";
3722     // Group picture
3723     if ($group !== -1) {  // Groups are active - group is a group data object or NULL
3724         echo '<td class="picture group">';
3725         if (!empty($group->picture) and empty($group->hidepicture)) {
3726             if ($canviewparticipants && $COURSE->groupmode) {
3727                 $picturelink = true;
3728             } else {
3729                 $picturelink = false;
3730             }
3731             print_group_picture($group, $forum->course, false, false, $picturelink);
3732         } else if (isset($group->id)) {
3733             if ($canviewparticipants && $COURSE->groupmode) {
3734                 echo '<a href="'.$CFG->wwwroot.'/user/index.php?id='.$forum->course.'&amp;group='.$group->id.'">'.$group->name.'</a>';
3735             } else {
3736                 echo $group->name;
3737             }
3738         }
3739         echo "</td>\n";
3740     }
3742     if (has_capability('mod/forum:viewdiscussion', $modcontext)) {   // Show the column with replies
3743         echo '<td class="replies">';
3744         echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
3745         echo $post->replies.'</a>';
3746         echo "</td>\n";
3748         if ($cantrack) {
3749             echo '<td class="replies">';
3750             if ($forumtracked) {
3751                 if ($post->unread > 0) {
3752                     echo '<span class="unread">';
3753                     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'#unread">';
3754                     echo $post->unread;
3755                     echo '</a>';
3756                     echo '<a title="'.$strmarkalldread.'" href="'.$CFG->wwwroot.'/mod/forum/markposts.php?f='.
3757                          $forum->id.'&amp;d='.$post->discussion.'&amp;mark=read&amp;returnpage=view.php">' .
3758                          '<img src="'.$OUTPUT->pix_url('t/markasread') . '" class="iconsmall" alt="'.$strmarkalldread.'" /></a>';
3759                     echo '</span>';
3760                 } else {
3761                     echo '<span class="read">';
3762                     echo $post->unread;
3763                     echo '</span>';
3764                 }
3765             } else {
3766                 echo '<span class="read">';
3767                 echo '-';
3768                 echo '</span>';
3769             }
3770             echo "</td>\n";
3771         }
3772     }
3774     echo '<td class="lastpost">';
3775     $usedate = (empty($post->timemodified)) ? $post->modified : $post->timemodified;  // Just in case
3776     $parenturl = '';
3777     $usermodified = new stdClass();
3778     $usermodified->id = $post->usermodified;
3779     $usermodified = username_load_fields_from_object($usermodified, $post, 'um');
3781     // In QA forums we check that the user can view participants.
3782     if ($forum->type !== 'qanda' || $canviewparticipants) {
3783         echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->usermodified.'&amp;course='.$forum->course.'">'.
3784              fullname($usermodified).'</a><br />';
3785         $parenturl = (empty($post->lastpostid)) ? '' : '&amp;parent='.$post->lastpostid;
3786     }
3788     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.$parenturl.'">'.
3789           userdate($usedate, $datestring).'</a>';
3790     echo "</td>\n";
3792     // is_guest should be used here as this also checks whether the user is a guest in the current course.
3793     // Guests and visitors cannot subscribe - only enrolled users.
3794     if ((!is_guest($modcontext, $USER) && isloggedin()) && has_capability('mod/forum:viewdiscussion', $modcontext)) {
3795         // Discussion subscription.
3796         if (\mod_forum\subscriptions::is_subscribable($forum)) {
3797             echo '<td class="discussionsubscription">';
3798             echo forum_get_discussion_subscription_icon($forum, $post->discussion);
3799             echo '</td>';
3800         }
3801     }
3803     echo "</tr>\n\n";
3807 /**
3808  * Return the markup for the discussion subscription toggling icon.
3809  *
3810  * @param stdClass $forum The forum object.
3811  * @param int $discussionid The discussion to create an icon for.
3812  * @return string The generated markup.
3813  */
3814 function forum_get_discussion_subscription_icon($forum, $discussionid, $returnurl = null, $includetext = false) {
3815     global $USER, $OUTPUT, $PAGE;
3817     if ($returnurl === null && $PAGE->url) {
3818         $returnurl = $PAGE->url->out();
3819     }
3821     $o = '';
3822     $subscriptionstatus = \mod_forum\subscriptions::is_subscribed($USER->id, $forum, $discussionid);
3823     $subscriptionlink = new moodle_url('/mod/forum/subscribe.php', array(
3824         'sesskey' => sesskey(),
3825         'id' => $forum->id,
3826         'd' => $discussionid,
3827         'returnurl' => $returnurl,
3828     ));
3830     if ($includetext) {
3831         $o .= $subscriptionstatus ? get_string('subscribed', 'mod_forum') : get_string('notsubscribed', 'mod_forum');
3832     }
3834     if ($subscriptionstatus) {
3835         $output = $OUTPUT->pix_icon('t/subscribed', get_string('clicktounsubscribe', 'forum'), 'mod_forum');
3836         if ($includetext) {
3837             $output .= get_string('subscribed', 'mod_forum');
3838         }
3840         return html_writer::link($subscriptionlink, $output, array(
3841                 'title' => get_string('clicktounsubscribe', 'forum'),
3842                 'class' => 'discussiontoggle iconsmall',
3843                 'data-forumid' => $forum->id,
3844                 'data-discussionid' => $discussionid,
3845                 'data-includetext' => $includetext,
3846             ));
3848     } else {
3849         $output = $OUTPUT->pix_icon('t/unsubscribed', get_string('clicktosubscribe', 'forum'), 'mod_forum');
3850         if ($includetext) {
3851             $output .= get_string('notsubscribed', 'mod_forum');
3852         }
3854         return html_writer::link($subscriptionlink, $output, array(
3855                 'title' => get_string('clicktosubscribe', 'forum'),
3856                 'class' => 'discussiontoggle iconsmall',
3857                 'data-forumid' => $forum->id,
3858                 'data-discussionid' => $discussionid,
3859                 'data-includetext' => $includetext,
3860             ));
3861     }
3864 /**
3865  * Return a pair of spans containing classes to allow the subscribe and
3866  * unsubscribe icons to be pre-loaded by a browser.
3867  *
3868  * @return string The generated markup
3869  */
3870 function forum_get_discussion_subscription_icon_preloaders() {
3871     $o = '';
3872     $o .= html_writer::span('&nbsp;', 'preload-subscribe');
3873     $o .= html_writer::span('&nbsp;', 'preload-unsubscribe');
3874     return $o;
3877 /**
3878  * Print the drop down that allows the user to select how they want to have
3879  * the discussion displayed.
3880  *
3881  * @param int $id forum id if $forumtype is 'single',
3882  *              discussion id for any other forum type
3883  * @param mixed $mode forum layout mode
3884  * @param string $forumtype optional
3885  */
3886 function forum_print_mode_form($id, $mode, $forumtype='') {
3887     global $OUTPUT;
3888     if ($forumtype == 'single') {
3889         $select = new single_select(new moodle_url("/mod/forum/view.php", array('f'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
3890         $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
3891         $select->class = "forummode";
3892     } else {
3893         $select = new single_select(new moodle_url("/mod/forum/discuss.php", array('d'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
3894         $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
3895     }
3896     echo $OUTPUT->render($select);
3899 /**
3900  * @global object
3901  * @param object $course
3902  * @param string $search
3903  * @return string
3904  */
3905 function forum_search_form($course, $search='') {
3906     global $CFG, $OUTPUT;
3908     $output  = '<div class="forumsearch">';
3909     $output .= '<form action="'.$CFG->wwwroot.'/mod/forum/search.php" style="display:inline">';
3910     $output .= '<fieldset class="invisiblefieldset">';
3911     $output .= $OUTPUT->help_icon('search');
3912     $output .= '<label class="accesshide" for="search" >'.get_string('search', 'forum').'</label>';
3913     $output .= '<input id="search" name="search" type="text" size="18" value="'.s($search, true).'" />';
3914     $output .= '<label class="accesshide" for="searchforums" >'.get_string('searchforums', 'forum').'</label>';
3915     $output .= '<input id="searchforums" value="'.get_string('searchforums', 'forum').'" type="submit" />';
3916     $output .= '<input name="id" type="hidden" value="'.$course->id.'" />';
3917     $output .= '</fieldset>';
3918     $output .= '</form>';
3919     $output .= '</div>';
3921     return $output;
3925 /**
3926  * @global object
3927  * @global object
3928  */
3929 function forum_set_return() {
3930     global $CFG, $SESSION;
3932     if (! isset($SESSION->fromdiscussion)) {
3933         $referer = get_local_referer(false);
3934         // If the referer is NOT a login screen then save it.
3935         if (! strncasecmp("$CFG->wwwroot/login", $referer, 300)) {
3936             $SESSION->fromdiscussion = $referer;
3937         }
3938     }
3942 /**
3943  * @global object
3944  * @param string $default
3945  * @return string
3946  */
3947 function forum_go_back_to($default) {
3948     global $SESSION;
3950     if (!empty($SESSION->fromdiscussion)) {
3951         $returnto = $SESSION->fromdiscussion;
3952         unset($SESSION->fromdiscussion);
3953         return $returnto;
3954     } else {
3955         return $default;
3956     }
3959 /**
3960  * Given a discussion object that is being moved to $forumto,
3961  * this function checks all posts in that discussion
3962  * for attachments, and if any are found, these are
3963  * moved to the new forum directory.
3964  *
3965  * @global object
3966  * @param object $discussion
3967  * @param int $forumfrom source forum id
3968  * @param int $forumto target forum id
3969  * @return bool success
3970  */
3971 function forum_move_attachments($discussion, $forumfrom, $forumto) {
3972     global $DB;
3974     $fs = get_file_storage();
3976     $newcm = get_coursemodule_from_instance('forum', $forumto);
3977     $oldcm = get_coursemodule_from_instance('forum', $forumfrom);
3979     $newcontext = context_module::instance($newcm->id);
3980     $oldcontext = context_module::instance($oldcm->id);
3982     // loop through all posts, better not use attachment flag ;-)
3983     if ($posts = $DB->get_records('forum_posts', array('discussion'=>$discussion->id), '', 'id, attachment')) {
3984         foreach ($posts as $post) {
3985             $fs->move_area_files_to_new_context($oldcontext->id,
3986                     $newcontext->id, 'mod_forum', 'post', $post->id);
3987             $attachmentsmoved = $fs->move_area_files_to_new_context($oldcontext->id,
3988                     $newcontext->id, 'mod_forum', 'attachment', $post->id);
3989             if ($attachmentsmoved > 0 && $post->attachment != '1') {
3990                 // Weird - let's fix it
3991                 $post->attachment = '1';
3992                 $DB->update_record('forum_posts', $post);
3993             } else if ($attachmentsmoved == 0 && $post->attachment != '') {
3994                 // Weird - let's fix it
3995                 $post->attachment = '';
3996                 $DB->update_record('forum_posts', $post);
3997             }
3998         }
3999     }
4001     return true;
4004 /**
4005  * Returns attachments as formated text/html optionally with separate images
4006  *
4007  * @global object
4008  * @global object
4009  * @global object
4010  * @param object $post
4011  * @param object $cm
4012  * @param string $type html/text/separateimages
4013  * @return mixed string or array of (html text withouth images and image HTML)
4014  */
4015 function forum_print_attachments($post, $cm, $type) {
4016     global $CFG, $DB, $USER, $OUTPUT;
4018     if (empty($post->attachment)) {
4019         return $type !== 'separateimages' ? '' : array('', '');
4020     }
4022     if (!in_array($type, array('separateimages', 'html', 'text'))) {
4023         return $type !== 'separateimages' ? '' : array('', '');
4024     }
4026     if (!$context = context_module::instance($cm->id)) {
4027         return $type !== 'separateimages' ? '' : array('', '');
4028     }
4029     $strattachment = get_string('attachment', 'forum');
4031     $fs = get_file_storage();
4033     $imagereturn = '';
4034     $output = '';
4036     $canexport = !empty($CFG->enableportfolios) && (has_capability('mod/forum:exportpost', $context) || ($post->userid == $USER->id && has_capability('mod/forum:exportownpost', $context)));
4038     if ($canexport) {
4039         require_once($CFG->libdir.'/portfoliolib.php');
4040     }
4042     // We retrieve all files according to the time that they were created.  In the case that several files were uploaded
4043     // at the sametime (e.g. in the case of drag/drop upload) we revert to using the filename.
4044     $files = $fs->get_area_files($context->id, 'mod_forum', 'attachment', $post->id, "filename", false);
4045     if ($files) {
4046         if ($canexport) {
4047             $button = new portfolio_add_button();
4048         }
4049         foreach ($files as $file) {
4050             $filename = $file->get_filename();
4051             $mimetype = $file->get_mimetype();
4052             $iconimage = $OUTPUT->pix_icon(file_file_icon($file), get_mimetype_description($file), 'moodle', array('class' => 'icon'));
4053             $path = file_encode_url($CFG->wwwroot.'/pluginfile.php', '/'.$context->id.'/mod_forum/attachment/'.$post->id.'/'.$filename);
4055             if ($type == 'html') {
4056                 $output .= "<a href=\"$path\">$iconimage</a> ";
4057                 $output .= "<a href=\"$path\">".s($filename)."</a>";
4058                 if ($canexport) {
4059                     $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
4060                     $button->set_format_by_file($file);
4061                     $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
4062                 }
4063                 $output .= "<br />";
4065             } else if ($type == 'text') {
4066                 $output .= "$strattachment ".s($filename).":\n$path\n";
4068             } else { //'returnimages'
4069                 if (in_array($mimetype, array('image/gif', 'image/jpeg', 'image/png'))) {
4070                     // Image attachments don't get printed as links
4071                     $imagereturn .= "<br /><img src=\"$path\" alt=\"\" />";
4072                     if ($canexport) {
4073                         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
4074                         $button->set_format_by_file($file);
4075                         $imagereturn .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
4076                     }
4077                 } else {
4078                     $output .= "<a href=\"$path\">$iconimage</a> ";