MDL-51836 mod_forum: Fix CASE statement breaking mssql & oracle.
[moodle.git] / mod / forum / lib.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * @package   mod_forum
19  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
20  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
21  */
23 defined('MOODLE_INTERNAL') || die();
25 /** Include required files */
26 require_once(__DIR__ . '/deprecatedlib.php');
27 require_once($CFG->libdir.'/filelib.php');
28 require_once($CFG->libdir.'/eventslib.php');
30 /// CONSTANTS ///////////////////////////////////////////////////////////
32 define('FORUM_MODE_FLATOLDEST', 1);
33 define('FORUM_MODE_FLATNEWEST', -1);
34 define('FORUM_MODE_THREADED', 2);
35 define('FORUM_MODE_NESTED', 3);
37 define('FORUM_CHOOSESUBSCRIBE', 0);
38 define('FORUM_FORCESUBSCRIBE', 1);
39 define('FORUM_INITIALSUBSCRIBE', 2);
40 define('FORUM_DISALLOWSUBSCRIBE',3);
42 /**
43  * FORUM_TRACKING_OFF - Tracking is not available for this forum.
44  */
45 define('FORUM_TRACKING_OFF', 0);
47 /**
48  * FORUM_TRACKING_OPTIONAL - Tracking is based on user preference.
49  */
50 define('FORUM_TRACKING_OPTIONAL', 1);
52 /**
53  * FORUM_TRACKING_FORCED - Tracking is on, regardless of user setting.
54  * Treated as FORUM_TRACKING_OPTIONAL if $CFG->forum_allowforcedreadtracking is off.
55  */
56 define('FORUM_TRACKING_FORCED', 2);
58 define('FORUM_MAILED_PENDING', 0);
59 define('FORUM_MAILED_SUCCESS', 1);
60 define('FORUM_MAILED_ERROR', 2);
62 if (!defined('FORUM_CRON_USER_CACHE')) {
63     /** Defines how many full user records are cached in forum cron. */
64     define('FORUM_CRON_USER_CACHE', 5000);
65 }
67 /**
68  * FORUM_POSTS_ALL_USER_GROUPS - All the posts in groups where the user is enrolled.
69  */
70 define('FORUM_POSTS_ALL_USER_GROUPS', -2);
72 /// STANDARD FUNCTIONS ///////////////////////////////////////////////////////////
74 /**
75  * Given an object containing all the necessary data,
76  * (defined by the form in mod_form.php) this function
77  * will create a new instance and return the id number
78  * of the new instance.
79  *
80  * @param stdClass $forum add forum instance
81  * @param mod_forum_mod_form $mform
82  * @return int intance id
83  */
84 function forum_add_instance($forum, $mform = null) {
85     global $CFG, $DB;
87     $forum->timemodified = time();
89     if (empty($forum->assessed)) {
90         $forum->assessed = 0;
91     }
93     if (empty($forum->ratingtime) or empty($forum->assessed)) {
94         $forum->assesstimestart  = 0;
95         $forum->assesstimefinish = 0;
96     }
98     $forum->id = $DB->insert_record('forum', $forum);
99     $modcontext = context_module::instance($forum->coursemodule);
101     if ($forum->type == 'single') {  // Create related discussion.
102         $discussion = new stdClass();
103         $discussion->course        = $forum->course;
104         $discussion->forum         = $forum->id;
105         $discussion->name          = $forum->name;
106         $discussion->assessed      = $forum->assessed;
107         $discussion->message       = $forum->intro;
108         $discussion->messageformat = $forum->introformat;
109         $discussion->messagetrust  = trusttext_trusted(context_course::instance($forum->course));
110         $discussion->mailnow       = false;
111         $discussion->groupid       = -1;
113         $message = '';
115         $discussion->id = forum_add_discussion($discussion, null, $message);
117         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
118             // Ugly hack - we need to copy the files somehow.
119             $discussion = $DB->get_record('forum_discussions', array('id'=>$discussion->id), '*', MUST_EXIST);
120             $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
122             $options = array('subdirs'=>true); // Use the same options as intro field!
123             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
124             $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
125         }
126     }
128     forum_grade_item_update($forum);
130     return $forum->id;
133 /**
134  * Handle changes following the creation of a forum instance.
135  * This function is typically called by the course_module_created observer.
136  *
137  * @param object $context the forum context
138  * @param stdClass $forum The forum object
139  * @return void
140  */
141 function forum_instance_created($context, $forum) {
142     if ($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) {
143         $users = \mod_forum\subscriptions::get_potential_subscribers($context, 0, 'u.id, u.email');
144         foreach ($users as $user) {
145             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $context);
146         }
147     }
150 /**
151  * Given an object containing all the necessary data,
152  * (defined by the form in mod_form.php) this function
153  * will update an existing instance with new data.
154  *
155  * @global object
156  * @param object $forum forum instance (with magic quotes)
157  * @return bool success
158  */
159 function forum_update_instance($forum, $mform) {
160     global $DB, $OUTPUT, $USER;
162     $forum->timemodified = time();
163     $forum->id           = $forum->instance;
165     if (empty($forum->assessed)) {
166         $forum->assessed = 0;
167     }
169     if (empty($forum->ratingtime) or empty($forum->assessed)) {
170         $forum->assesstimestart  = 0;
171         $forum->assesstimefinish = 0;
172     }
174     $oldforum = $DB->get_record('forum', array('id'=>$forum->id));
176     // MDL-3942 - if the aggregation type or scale (i.e. max grade) changes then recalculate the grades for the entire forum
177     // if  scale changes - do we need to recheck the ratings, if ratings higher than scale how do we want to respond?
178     // 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
179     if (($oldforum->assessed<>$forum->assessed) or ($oldforum->scale<>$forum->scale)) {
180         forum_update_grades($forum); // recalculate grades for the forum
181     }
183     if ($forum->type == 'single') {  // Update related discussion and post.
184         $discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id), 'timemodified ASC');
185         if (!empty($discussions)) {
186             if (count($discussions) > 1) {
187                 echo $OUTPUT->notification(get_string('warnformorepost', 'forum'));
188             }
189             $discussion = array_pop($discussions);
190         } else {
191             // try to recover by creating initial discussion - MDL-16262
192             $discussion = new stdClass();
193             $discussion->course          = $forum->course;
194             $discussion->forum           = $forum->id;
195             $discussion->name            = $forum->name;
196             $discussion->assessed        = $forum->assessed;
197             $discussion->message         = $forum->intro;
198             $discussion->messageformat   = $forum->introformat;
199             $discussion->messagetrust    = true;
200             $discussion->mailnow         = false;
201             $discussion->groupid         = -1;
203             $message = '';
205             forum_add_discussion($discussion, null, $message);
207             if (! $discussion = $DB->get_record('forum_discussions', array('forum'=>$forum->id))) {
208                 print_error('cannotadd', 'forum');
209             }
210         }
211         if (! $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost))) {
212             print_error('cannotfindfirstpost', 'forum');
213         }
215         $cm         = get_coursemodule_from_instance('forum', $forum->id);
216         $modcontext = context_module::instance($cm->id, MUST_EXIST);
218         $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
219         $post->subject       = $forum->name;
220         $post->message       = $forum->intro;
221         $post->messageformat = $forum->introformat;
222         $post->messagetrust  = trusttext_trusted($modcontext);
223         $post->modified      = $forum->timemodified;
224         $post->userid        = $USER->id;    // MDL-18599, so that current teacher can take ownership of activities.
226         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
227             // Ugly hack - we need to copy the files somehow.
228             $options = array('subdirs'=>true); // Use the same options as intro field!
229             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
230         }
232         $DB->update_record('forum_posts', $post);
233         $discussion->name = $forum->name;
234         $DB->update_record('forum_discussions', $discussion);
235     }
237     $DB->update_record('forum', $forum);
239     $modcontext = context_module::instance($forum->coursemodule);
240     if (($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) && ($oldforum->forcesubscribe <> $forum->forcesubscribe)) {
241         $users = \mod_forum\subscriptions::get_potential_subscribers($modcontext, 0, 'u.id, u.email', '');
242         foreach ($users as $user) {
243             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $modcontext);
244         }
245     }
247     forum_grade_item_update($forum);
249     return true;
253 /**
254  * Given an ID of an instance of this module,
255  * this function will permanently delete the instance
256  * and any data that depends on it.
257  *
258  * @global object
259  * @param int $id forum instance id
260  * @return bool success
261  */
262 function forum_delete_instance($id) {
263     global $DB;
265     if (!$forum = $DB->get_record('forum', array('id'=>$id))) {
266         return false;
267     }
268     if (!$cm = get_coursemodule_from_instance('forum', $forum->id)) {
269         return false;
270     }
271     if (!$course = $DB->get_record('course', array('id'=>$cm->course))) {
272         return false;
273     }
275     $context = context_module::instance($cm->id);
277     // now get rid of all files
278     $fs = get_file_storage();
279     $fs->delete_area_files($context->id);
281     $result = true;
283     // Delete digest and subscription preferences.
284     $DB->delete_records('forum_digests', array('forum' => $forum->id));
285     $DB->delete_records('forum_subscriptions', array('forum'=>$forum->id));
286     $DB->delete_records('forum_discussion_subs', array('forum' => $forum->id));
288     if ($discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id))) {
289         foreach ($discussions as $discussion) {
290             if (!forum_delete_discussion($discussion, true, $course, $cm, $forum)) {
291                 $result = false;
292             }
293         }
294     }
296     forum_tp_delete_read_records(-1, -1, -1, $forum->id);
298     if (!$DB->delete_records('forum', array('id'=>$forum->id))) {
299         $result = false;
300     }
302     forum_grade_item_delete($forum);
304     return $result;
308 /**
309  * Indicates API features that the forum supports.
310  *
311  * @uses FEATURE_GROUPS
312  * @uses FEATURE_GROUPINGS
313  * @uses FEATURE_MOD_INTRO
314  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
315  * @uses FEATURE_COMPLETION_HAS_RULES
316  * @uses FEATURE_GRADE_HAS_GRADE
317  * @uses FEATURE_GRADE_OUTCOMES
318  * @param string $feature
319  * @return mixed True if yes (some features may use other values)
320  */
321 function forum_supports($feature) {
322     switch($feature) {
323         case FEATURE_GROUPS:                  return true;
324         case FEATURE_GROUPINGS:               return true;
325         case FEATURE_MOD_INTRO:               return true;
326         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
327         case FEATURE_COMPLETION_HAS_RULES:    return true;
328         case FEATURE_GRADE_HAS_GRADE:         return true;
329         case FEATURE_GRADE_OUTCOMES:          return true;
330         case FEATURE_RATE:                    return true;
331         case FEATURE_BACKUP_MOODLE2:          return true;
332         case FEATURE_SHOW_DESCRIPTION:        return true;
333         case FEATURE_PLAGIARISM:              return true;
335         default: return null;
336     }
340 /**
341  * Obtains the automatic completion state for this forum based on any conditions
342  * in forum settings.
343  *
344  * @global object
345  * @global object
346  * @param object $course Course
347  * @param object $cm Course-module
348  * @param int $userid User ID
349  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
350  * @return bool True if completed, false if not. (If no conditions, then return
351  *   value depends on comparison type)
352  */
353 function forum_get_completion_state($course,$cm,$userid,$type) {
354     global $CFG,$DB;
356     // Get forum details
357     if (!($forum=$DB->get_record('forum',array('id'=>$cm->instance)))) {
358         throw new Exception("Can't find forum {$cm->instance}");
359     }
361     $result=$type; // Default return value
363     $postcountparams=array('userid'=>$userid,'forumid'=>$forum->id);
364     $postcountsql="
365 SELECT
366     COUNT(1)
367 FROM
368     {forum_posts} fp
369     INNER JOIN {forum_discussions} fd ON fp.discussion=fd.id
370 WHERE
371     fp.userid=:userid AND fd.forum=:forumid";
373     if ($forum->completiondiscussions) {
374         $value = $forum->completiondiscussions <=
375                  $DB->count_records('forum_discussions',array('forum'=>$forum->id,'userid'=>$userid));
376         if ($type == COMPLETION_AND) {
377             $result = $result && $value;
378         } else {
379             $result = $result || $value;
380         }
381     }
382     if ($forum->completionreplies) {
383         $value = $forum->completionreplies <=
384                  $DB->get_field_sql( $postcountsql.' AND fp.parent<>0',$postcountparams);
385         if ($type==COMPLETION_AND) {
386             $result = $result && $value;
387         } else {
388             $result = $result || $value;
389         }
390     }
391     if ($forum->completionposts) {
392         $value = $forum->completionposts <= $DB->get_field_sql($postcountsql,$postcountparams);
393         if ($type == COMPLETION_AND) {
394             $result = $result && $value;
395         } else {
396             $result = $result || $value;
397         }
398     }
400     return $result;
403 /**
404  * Create a message-id string to use in the custom headers of forum notification emails
405  *
406  * message-id is used by email clients to identify emails and to nest conversations
407  *
408  * @param int $postid The ID of the forum post we are notifying the user about
409  * @param int $usertoid The ID of the user being notified
410  * @param string $hostname The server's hostname
411  * @return string A unique message-id
412  */
413 function forum_get_email_message_id($postid, $usertoid, $hostname) {
414     return '<'.hash('sha256',$postid.'to'.$usertoid).'@'.$hostname.'>';
417 /**
418  * Removes properties from user record that are not necessary
419  * for sending post notifications.
420  * @param stdClass $user
421  * @return void, $user parameter is modified
422  */
423 function forum_cron_minimise_user_record(stdClass $user) {
425     // We store large amount of users in one huge array,
426     // make sure we do not store info there we do not actually need
427     // in mail generation code or messaging.
429     unset($user->institution);
430     unset($user->department);
431     unset($user->address);
432     unset($user->city);
433     unset($user->url);
434     unset($user->currentlogin);
435     unset($user->description);
436     unset($user->descriptionformat);
439 /**
440  * Function to be run periodically according to the scheduled task.
441  *
442  * Finds all posts that have yet to be mailed out, and mails them
443  * out to all subscribers as well as other maintance tasks.
444  *
445  * NOTE: Since 2.7.2 this function is run by scheduled task rather
446  * than standard cron.
447  *
448  * @todo MDL-44734 The function will be split up into seperate tasks.
449  */
450 function forum_cron() {
451     global $CFG, $USER, $DB, $PAGE;
453     $site = get_site();
455     // The main renderers.
456     $htmlout = $PAGE->get_renderer('mod_forum', 'email', 'htmlemail');
457     $textout = $PAGE->get_renderer('mod_forum', 'email', 'textemail');
458     $htmldigestfullout = $PAGE->get_renderer('mod_forum', 'emaildigestfull', 'htmlemail');
459     $textdigestfullout = $PAGE->get_renderer('mod_forum', 'emaildigestfull', 'textemail');
460     $htmldigestbasicout = $PAGE->get_renderer('mod_forum', 'emaildigestbasic', 'htmlemail');
461     $textdigestbasicout = $PAGE->get_renderer('mod_forum', 'emaildigestbasic', 'textemail');
463     // All users that are subscribed to any post that needs sending,
464     // please increase $CFG->extramemorylimit on large sites that
465     // send notifications to a large number of users.
466     $users = array();
467     $userscount = 0; // Cached user counter - count($users) in PHP is horribly slow!!!
469     // Status arrays.
470     $mailcount  = array();
471     $errorcount = array();
473     // caches
474     $discussions        = array();
475     $forums             = array();
476     $courses            = array();
477     $coursemodules      = array();
478     $subscribedusers    = array();
479     $messageinboundhandlers = array();
481     // Posts older than 2 days will not be mailed.  This is to avoid the problem where
482     // cron has not been running for a long time, and then suddenly people are flooded
483     // with mail from the past few weeks or months
484     $timenow   = time();
485     $endtime   = $timenow - $CFG->maxeditingtime;
486     $starttime = $endtime - 48 * 3600;   // Two days earlier
488     // Get the list of forum subscriptions for per-user per-forum maildigest settings.
489     $digestsset = $DB->get_recordset('forum_digests', null, '', 'id, userid, forum, maildigest');
490     $digests = array();
491     foreach ($digestsset as $thisrow) {
492         if (!isset($digests[$thisrow->forum])) {
493             $digests[$thisrow->forum] = array();
494         }
495         $digests[$thisrow->forum][$thisrow->userid] = $thisrow->maildigest;
496     }
497     $digestsset->close();
499     // Create the generic messageinboundgenerator.
500     $messageinboundgenerator = new \core\message\inbound\address_manager();
501     $messageinboundgenerator->set_handler('\mod_forum\message\inbound\reply_handler');
503     if ($posts = forum_get_unmailed_posts($starttime, $endtime, $timenow)) {
504         // Mark them all now as being mailed.  It's unlikely but possible there
505         // might be an error later so that a post is NOT actually mailed out,
506         // but since mail isn't crucial, we can accept this risk.  Doing it now
507         // prevents the risk of duplicated mails, which is a worse problem.
509         if (!forum_mark_old_posts_as_mailed($endtime)) {
510             mtrace('Errors occurred while trying to mark some posts as being mailed.');
511             return false;  // Don't continue trying to mail them, in case we are in a cron loop
512         }
514         // checking post validity, and adding users to loop through later
515         foreach ($posts as $pid => $post) {
517             $discussionid = $post->discussion;
518             if (!isset($discussions[$discussionid])) {
519                 if ($discussion = $DB->get_record('forum_discussions', array('id'=> $post->discussion))) {
520                     $discussions[$discussionid] = $discussion;
521                     \mod_forum\subscriptions::fill_subscription_cache($discussion->forum);
522                     \mod_forum\subscriptions::fill_discussion_subscription_cache($discussion->forum);
524                 } else {
525                     mtrace('Could not find discussion ' . $discussionid);
526                     unset($posts[$pid]);
527                     continue;
528                 }
529             }
530             $forumid = $discussions[$discussionid]->forum;
531             if (!isset($forums[$forumid])) {
532                 if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
533                     $forums[$forumid] = $forum;
534                 } else {
535                     mtrace('Could not find forum '.$forumid);
536                     unset($posts[$pid]);
537                     continue;
538                 }
539             }
540             $courseid = $forums[$forumid]->course;
541             if (!isset($courses[$courseid])) {
542                 if ($course = $DB->get_record('course', array('id' => $courseid))) {
543                     $courses[$courseid] = $course;
544                 } else {
545                     mtrace('Could not find course '.$courseid);
546                     unset($posts[$pid]);
547                     continue;
548                 }
549             }
550             if (!isset($coursemodules[$forumid])) {
551                 if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
552                     $coursemodules[$forumid] = $cm;
553                 } else {
554                     mtrace('Could not find course module for forum '.$forumid);
555                     unset($posts[$pid]);
556                     continue;
557                 }
558             }
560             // Save the Inbound Message datakey here to reduce DB queries later.
561             $messageinboundgenerator->set_data($pid);
562             $messageinboundhandlers[$pid] = $messageinboundgenerator->fetch_data_key();
564             // Caching subscribed users of each forum.
565             if (!isset($subscribedusers[$forumid])) {
566                 $modcontext = context_module::instance($coursemodules[$forumid]->id);
567                 if ($subusers = \mod_forum\subscriptions::fetch_subscribed_users($forums[$forumid], 0, $modcontext, 'u.*', true)) {
569                     foreach ($subusers as $postuser) {
570                         // this user is subscribed to this forum
571                         $subscribedusers[$forumid][$postuser->id] = $postuser->id;
572                         $userscount++;
573                         if ($userscount > FORUM_CRON_USER_CACHE) {
574                             // Store minimal user info.
575                             $minuser = new stdClass();
576                             $minuser->id = $postuser->id;
577                             $users[$postuser->id] = $minuser;
578                         } else {
579                             // Cache full user record.
580                             forum_cron_minimise_user_record($postuser);
581                             $users[$postuser->id] = $postuser;
582                         }
583                     }
584                     // Release memory.
585                     unset($subusers);
586                     unset($postuser);
587                 }
588             }
589             $mailcount[$pid] = 0;
590             $errorcount[$pid] = 0;
591         }
592     }
594     if ($users && $posts) {
596         $urlinfo = parse_url($CFG->wwwroot);
597         $hostname = $urlinfo['host'];
599         foreach ($users as $userto) {
600             // Terminate if processing of any account takes longer than 2 minutes.
601             core_php_time_limit::raise(120);
603             mtrace('Processing user ' . $userto->id);
605             // Init user caches - we keep the cache for one cycle only, otherwise it could consume too much memory.
606             if (isset($userto->username)) {
607                 $userto = clone($userto);
608             } else {
609                 $userto = $DB->get_record('user', array('id' => $userto->id));
610                 forum_cron_minimise_user_record($userto);
611             }
612             $userto->viewfullnames = array();
613             $userto->canpost       = array();
614             $userto->markposts     = array();
616             // Setup this user so that the capabilities are cached, and environment matches receiving user.
617             cron_setup_user($userto);
619             // Reset the caches.
620             foreach ($coursemodules as $forumid => $unused) {
621                 $coursemodules[$forumid]->cache       = new stdClass();
622                 $coursemodules[$forumid]->cache->caps = array();
623                 unset($coursemodules[$forumid]->uservisible);
624             }
626             foreach ($posts as $pid => $post) {
627                 $discussion = $discussions[$post->discussion];
628                 $forum      = $forums[$discussion->forum];
629                 $course     = $courses[$forum->course];
630                 $cm         =& $coursemodules[$forum->id];
632                 // Do some checks to see if we can bail out now.
634                 // Only active enrolled users are in the list of subscribers.
635                 // This does not necessarily mean that the user is subscribed to the forum or to the discussion though.
636                 if (!isset($subscribedusers[$forum->id][$userto->id])) {
637                     // The user does not subscribe to this forum.
638                     continue;
639                 }
641                 if (!\mod_forum\subscriptions::is_subscribed($userto->id, $forum, $post->discussion, $coursemodules[$forum->id])) {
642                     // The user does not subscribe to this forum, or to this specific discussion.
643                     continue;
644                 }
646                 if ($subscriptiontime = \mod_forum\subscriptions::fetch_discussion_subscription($forum->id, $userto->id)) {
647                     // Skip posts if the user subscribed to the discussion after it was created.
648                     if (isset($subscriptiontime[$post->discussion]) && ($subscriptiontime[$post->discussion] > $post->created)) {
649                         continue;
650                     }
651                 }
653                 // Don't send email if the forum is Q&A and the user has not posted.
654                 // Initial topics are still mailed.
655                 if ($forum->type == 'qanda' && !forum_get_user_posted_time($discussion->id, $userto->id) && $pid != $discussion->firstpost) {
656                     mtrace('Did not email ' . $userto->id.' because user has not posted in discussion');
657                     continue;
658                 }
660                 // Get info about the sending user.
661                 if (array_key_exists($post->userid, $users)) {
662                     // We might know the user already.
663                     $userfrom = $users[$post->userid];
664                     if (!isset($userfrom->idnumber)) {
665                         // Minimalised user info, fetch full record.
666                         $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
667                         forum_cron_minimise_user_record($userfrom);
668                     }
670                 } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
671                     forum_cron_minimise_user_record($userfrom);
672                     // Fetch only once if possible, we can add it to user list, it will be skipped anyway.
673                     if ($userscount <= FORUM_CRON_USER_CACHE) {
674                         $userscount++;
675                         $users[$userfrom->id] = $userfrom;
676                     }
677                 } else {
678                     mtrace('Could not find user ' . $post->userid . ', author of post ' . $post->id . '. Unable to send message.');
679                     continue;
680                 }
682                 // Note: If we want to check that userto and userfrom are not the same person this is probably the spot to do it.
684                 // Setup global $COURSE properly - needed for roles and languages.
685                 cron_setup_user($userto, $course);
687                 // Fill caches.
688                 if (!isset($userto->viewfullnames[$forum->id])) {
689                     $modcontext = context_module::instance($cm->id);
690                     $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
691                 }
692                 if (!isset($userto->canpost[$discussion->id])) {
693                     $modcontext = context_module::instance($cm->id);
694                     $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
695                 }
696                 if (!isset($userfrom->groups[$forum->id])) {
697                     if (!isset($userfrom->groups)) {
698                         $userfrom->groups = array();
699                         if (isset($users[$userfrom->id])) {
700                             $users[$userfrom->id]->groups = array();
701                         }
702                     }
703                     $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
704                     if (isset($users[$userfrom->id])) {
705                         $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
706                     }
707                 }
709                 // Make sure groups allow this user to see this email.
710                 if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {
711                     // Groups are being used.
712                     if (!groups_group_exists($discussion->groupid)) {
713                         // Can't find group - be safe and don't this message.
714                         continue;
715                     }
717                     if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $modcontext)) {
718                         // Do not send posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS.
719                         continue;
720                     }
721                 }
723                 // Make sure we're allowed to see the post.
724                 if (!forum_user_can_see_post($forum, $discussion, $post, null, $cm)) {
725                     mtrace('User ' . $userto->id .' can not see ' . $post->id . '. Not sending message.');
726                     continue;
727                 }
729                 // OK so we need to send the email.
731                 // Does the user want this post in a digest?  If so postpone it for now.
732                 $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
734                 if ($maildigest > 0) {
735                     // This user wants the mails to be in digest form.
736                     $queue = new stdClass();
737                     $queue->userid       = $userto->id;
738                     $queue->discussionid = $discussion->id;
739                     $queue->postid       = $post->id;
740                     $queue->timemodified = $post->created;
741                     $DB->insert_record('forum_queue', $queue);
742                     continue;
743                 }
745                 // Prepare to actually send the post now, and build up the content.
747                 $cleanforumname = str_replace('"', "'", strip_tags(format_string($forum->name)));
749                 $userfrom->customheaders = array (
750                     // Headers to make emails easier to track.
751                     'List-Id: "'        . $cleanforumname . '" <moodleforum' . $forum->id . '@' . $hostname.'>',
752                     'List-Help: '       . $CFG->wwwroot . '/mod/forum/view.php?f=' . $forum->id,
753                     'Message-ID: '      . forum_get_email_message_id($post->id, $userto->id, $hostname),
754                     'X-Course-Id: '     . $course->id,
755                     'X-Course-Name: '   . format_string($course->fullname, true),
757                     // Headers to help prevent auto-responders.
758                     'Precedence: Bulk',
759                     'X-Auto-Response-Suppress: All',
760                     'Auto-Submitted: auto-generated',
761                 );
763                 if ($post->parent) {
764                     // This post is a reply, so add headers for threading (see MDL-22551).
765                     $userfrom->customheaders[] = 'In-Reply-To: ' . forum_get_email_message_id($post->parent, $userto->id, $hostname);
766                     $userfrom->customheaders[] = 'References: '  . forum_get_email_message_id($post->parent, $userto->id, $hostname);
767                 }
769                 $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
771                 // Generate a reply-to address from using the Inbound Message handler.
772                 $replyaddress = null;
773                 if ($userto->canpost[$discussion->id] && array_key_exists($post->id, $messageinboundhandlers)) {
774                     $messageinboundgenerator->set_data($post->id, $messageinboundhandlers[$post->id]);
775                     $replyaddress = $messageinboundgenerator->generate($userto->id);
776                 }
778                 if (!isset($userto->canpost[$discussion->id])) {
779                     $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
780                 } else {
781                     $canreply = $userto->canpost[$discussion->id];
782                 }
784                 $data = new \mod_forum\output\forum_post_email(
785                         $course,
786                         $cm,
787                         $forum,
788                         $discussion,
789                         $post,
790                         $userfrom,
791                         $userto,
792                         $canreply
793                     );
795                 if (!isset($userto->viewfullnames[$forum->id])) {
796                     $data->viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
797                 } else {
798                     $data->viewfullnames = $userto->viewfullnames[$forum->id];
799                 }
801                 $a = new stdClass();
802                 $a->courseshortname = $data->get_coursename();
803                 $a->forumname = $cleanforumname;
804                 $a->subject = $data->get_subject();
805                 $postsubject = html_to_text(get_string('postmailsubject', 'forum', $a), 0);
807                 // Send the post now!
808                 mtrace('Sending ', '');
810                 $eventdata = new \core\message\message();
811                 $eventdata->component           = 'mod_forum';
812                 $eventdata->name                = 'posts';
813                 $eventdata->userfrom            = $userfrom;
814                 $eventdata->userto              = $userto;
815                 $eventdata->subject             = $postsubject;
816                 $eventdata->fullmessage         = $textout->render($data);
817                 $eventdata->fullmessageformat   = FORMAT_PLAIN;
818                 $eventdata->fullmessagehtml     = $htmlout->render($data);
819                 $eventdata->notification        = 1;
820                 $eventdata->replyto             = $replyaddress;
821                 if (!empty($replyaddress)) {
822                     // Add extra text to email messages if they can reply back.
823                     $textfooter = "\n\n" . get_string('replytopostbyemail', 'mod_forum');
824                     $htmlfooter = html_writer::tag('p', get_string('replytopostbyemail', 'mod_forum'));
825                     $additionalcontent = array('fullmessage' => array('footer' => $textfooter),
826                                      'fullmessagehtml' => array('footer' => $htmlfooter));
827                     $eventdata->set_additional_content('email', $additionalcontent);
828                 }
830                 // If forum_replytouser is not set then send mail using the noreplyaddress.
831                 if (empty($CFG->forum_replytouser)) {
832                     $eventdata->userfrom = core_user::get_noreply_user();
833                 }
835                 $smallmessagestrings = new stdClass();
836                 $smallmessagestrings->user          = fullname($userfrom);
837                 $smallmessagestrings->forumname     = "$shortname: " . format_string($forum->name, true) . ": " . $discussion->name;
838                 $smallmessagestrings->message       = $post->message;
840                 // Make sure strings are in message recipients language.
841                 $eventdata->smallmessage = get_string_manager()->get_string('smallmessage', 'forum', $smallmessagestrings, $userto->lang);
843                 $contexturl = new moodle_url('/mod/forum/discuss.php', array('d' => $discussion->id), 'p' . $post->id);
844                 $eventdata->contexturl = $contexturl->out();
845                 $eventdata->contexturlname = $discussion->name;
847                 $mailresult = message_send($eventdata);
848                 if (!$mailresult) {
849                     mtrace("Error: mod/forum/lib.php forum_cron(): Could not send out mail for id $post->id to user $userto->id".
850                             " ($userto->email) .. not trying again.");
851                     $errorcount[$post->id]++;
852                 } else {
853                     $mailcount[$post->id]++;
855                     // Mark post as read if forum_usermarksread is set off.
856                     if (!$CFG->forum_usermarksread) {
857                         $userto->markposts[$post->id] = $post->id;
858                     }
859                 }
861                 mtrace('post ' . $post->id . ': ' . $post->subject);
862             }
864             // Mark processed posts as read.
865             forum_tp_mark_posts_read($userto, $userto->markposts);
866             unset($userto);
867         }
868     }
870     if ($posts) {
871         foreach ($posts as $post) {
872             mtrace($mailcount[$post->id]." users were sent post $post->id, '$post->subject'");
873             if ($errorcount[$post->id]) {
874                 $DB->set_field('forum_posts', 'mailed', FORUM_MAILED_ERROR, array('id' => $post->id));
875             }
876         }
877     }
879     // release some memory
880     unset($subscribedusers);
881     unset($mailcount);
882     unset($errorcount);
884     cron_setup_user();
886     $sitetimezone = core_date::get_server_timezone();
888     // Now see if there are any digest mails waiting to be sent, and if we should send them
890     mtrace('Starting digest processing...');
892     core_php_time_limit::raise(300); // terminate if not able to fetch all digests in 5 minutes
894     if (!isset($CFG->digestmailtimelast)) {    // To catch the first time
895         set_config('digestmailtimelast', 0);
896     }
898     $timenow = time();
899     $digesttime = usergetmidnight($timenow, $sitetimezone) + ($CFG->digestmailtime * 3600);
901     // Delete any really old ones (normally there shouldn't be any)
902     $weekago = $timenow - (7 * 24 * 3600);
903     $DB->delete_records_select('forum_queue', "timemodified < ?", array($weekago));
904     mtrace ('Cleaned old digest records');
906     if ($CFG->digestmailtimelast < $digesttime and $timenow > $digesttime) {
908         mtrace('Sending forum digests: '.userdate($timenow, '', $sitetimezone));
910         $digestposts_rs = $DB->get_recordset_select('forum_queue', "timemodified < ?", array($digesttime));
912         if ($digestposts_rs->valid()) {
914             // We have work to do
915             $usermailcount = 0;
917             //caches - reuse the those filled before too
918             $discussionposts = array();
919             $userdiscussions = array();
921             foreach ($digestposts_rs as $digestpost) {
922                 if (!isset($posts[$digestpost->postid])) {
923                     if ($post = $DB->get_record('forum_posts', array('id' => $digestpost->postid))) {
924                         $posts[$digestpost->postid] = $post;
925                     } else {
926                         continue;
927                     }
928                 }
929                 $discussionid = $digestpost->discussionid;
930                 if (!isset($discussions[$discussionid])) {
931                     if ($discussion = $DB->get_record('forum_discussions', array('id' => $discussionid))) {
932                         $discussions[$discussionid] = $discussion;
933                     } else {
934                         continue;
935                     }
936                 }
937                 $forumid = $discussions[$discussionid]->forum;
938                 if (!isset($forums[$forumid])) {
939                     if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
940                         $forums[$forumid] = $forum;
941                     } else {
942                         continue;
943                     }
944                 }
946                 $courseid = $forums[$forumid]->course;
947                 if (!isset($courses[$courseid])) {
948                     if ($course = $DB->get_record('course', array('id' => $courseid))) {
949                         $courses[$courseid] = $course;
950                     } else {
951                         continue;
952                     }
953                 }
955                 if (!isset($coursemodules[$forumid])) {
956                     if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
957                         $coursemodules[$forumid] = $cm;
958                     } else {
959                         continue;
960                     }
961                 }
962                 $userdiscussions[$digestpost->userid][$digestpost->discussionid] = $digestpost->discussionid;
963                 $discussionposts[$digestpost->discussionid][$digestpost->postid] = $digestpost->postid;
964             }
965             $digestposts_rs->close(); /// Finished iteration, let's close the resultset
967             // Data collected, start sending out emails to each user
968             foreach ($userdiscussions as $userid => $thesediscussions) {
970                 core_php_time_limit::raise(120); // terminate if processing of any account takes longer than 2 minutes
972                 cron_setup_user();
974                 mtrace(get_string('processingdigest', 'forum', $userid), '... ');
976                 // First of all delete all the queue entries for this user
977                 $DB->delete_records_select('forum_queue', "userid = ? AND timemodified < ?", array($userid, $digesttime));
979                 // Init user caches - we keep the cache for one cycle only,
980                 // otherwise it would unnecessarily consume memory.
981                 if (array_key_exists($userid, $users) and isset($users[$userid]->username)) {
982                     $userto = clone($users[$userid]);
983                 } else {
984                     $userto = $DB->get_record('user', array('id' => $userid));
985                     forum_cron_minimise_user_record($userto);
986                 }
987                 $userto->viewfullnames = array();
988                 $userto->canpost       = array();
989                 $userto->markposts     = array();
991                 // Override the language and timezone of the "current" user, so that
992                 // mail is customised for the receiver.
993                 cron_setup_user($userto);
995                 $postsubject = get_string('digestmailsubject', 'forum', format_string($site->shortname, true));
997                 $headerdata = new stdClass();
998                 $headerdata->sitename = format_string($site->fullname, true);
999                 $headerdata->userprefs = $CFG->wwwroot.'/user/edit.php?id='.$userid.'&amp;course='.$site->id;
1001                 $posttext = get_string('digestmailheader', 'forum', $headerdata)."\n\n";
1002                 $headerdata->userprefs = '<a target="_blank" href="'.$headerdata->userprefs.'">'.get_string('digestmailprefs', 'forum').'</a>';
1004                 $posthtml = "<head>";
1005 /*                foreach ($CFG->stylesheets as $stylesheet) {
1006                     //TODO: MDL-21120
1007                     $posthtml .= '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'" />'."\n";
1008                 }*/
1009                 $posthtml .= "</head>\n<body id=\"email\">\n";
1010                 $posthtml .= '<p>'.get_string('digestmailheader', 'forum', $headerdata).'</p><br /><hr size="1" noshade="noshade" />';
1012                 foreach ($thesediscussions as $discussionid) {
1014                     core_php_time_limit::raise(120);   // to be reset for each post
1016                     $discussion = $discussions[$discussionid];
1017                     $forum      = $forums[$discussion->forum];
1018                     $course     = $courses[$forum->course];
1019                     $cm         = $coursemodules[$forum->id];
1021                     //override language
1022                     cron_setup_user($userto, $course);
1024                     // Fill caches
1025                     if (!isset($userto->viewfullnames[$forum->id])) {
1026                         $modcontext = context_module::instance($cm->id);
1027                         $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
1028                     }
1029                     if (!isset($userto->canpost[$discussion->id])) {
1030                         $modcontext = context_module::instance($cm->id);
1031                         $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1032                     }
1034                     $strforums      = get_string('forums', 'forum');
1035                     $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
1036                     $canreply       = $userto->canpost[$discussion->id];
1037                     $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1039                     $posttext .= "\n \n";
1040                     $posttext .= '=====================================================================';
1041                     $posttext .= "\n \n";
1042                     $posttext .= "$shortname -> $strforums -> ".format_string($forum->name,true);
1043                     if ($discussion->name != $forum->name) {
1044                         $posttext  .= " -> ".format_string($discussion->name,true);
1045                     }
1046                     $posttext .= "\n";
1047                     $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1048                     $posttext .= "\n";
1050                     $posthtml .= "<p><font face=\"sans-serif\">".
1051                     "<a target=\"_blank\" href=\"$CFG->wwwroot/course/view.php?id=$course->id\">$shortname</a> -> ".
1052                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/index.php?id=$course->id\">$strforums</a> -> ".
1053                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/view.php?f=$forum->id\">".format_string($forum->name,true)."</a>";
1054                     if ($discussion->name == $forum->name) {
1055                         $posthtml .= "</font></p>";
1056                     } else {
1057                         $posthtml .= " -> <a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id\">".format_string($discussion->name,true)."</a></font></p>";
1058                     }
1059                     $posthtml .= '<p>';
1061                     $postsarray = $discussionposts[$discussionid];
1062                     sort($postsarray);
1064                     foreach ($postsarray as $postid) {
1065                         $post = $posts[$postid];
1067                         if (array_key_exists($post->userid, $users)) { // we might know him/her already
1068                             $userfrom = $users[$post->userid];
1069                             if (!isset($userfrom->idnumber)) {
1070                                 $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
1071                                 forum_cron_minimise_user_record($userfrom);
1072                             }
1074                         } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
1075                             forum_cron_minimise_user_record($userfrom);
1076                             if ($userscount <= FORUM_CRON_USER_CACHE) {
1077                                 $userscount++;
1078                                 $users[$userfrom->id] = $userfrom;
1079                             }
1081                         } else {
1082                             mtrace('Could not find user '.$post->userid);
1083                             continue;
1084                         }
1086                         if (!isset($userfrom->groups[$forum->id])) {
1087                             if (!isset($userfrom->groups)) {
1088                                 $userfrom->groups = array();
1089                                 if (isset($users[$userfrom->id])) {
1090                                     $users[$userfrom->id]->groups = array();
1091                                 }
1092                             }
1093                             $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
1094                             if (isset($users[$userfrom->id])) {
1095                                 $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
1096                             }
1097                         }
1099                         // Headers to help prevent auto-responders.
1100                         $userfrom->customheaders = array(
1101                                 "Precedence: Bulk",
1102                                 'X-Auto-Response-Suppress: All',
1103                                 'Auto-Submitted: auto-generated',
1104                             );
1106                         $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
1107                         if (!isset($userto->canpost[$discussion->id])) {
1108                             $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1109                         } else {
1110                             $canreply = $userto->canpost[$discussion->id];
1111                         }
1113                         $data = new \mod_forum\output\forum_post_email(
1114                                 $course,
1115                                 $cm,
1116                                 $forum,
1117                                 $discussion,
1118                                 $post,
1119                                 $userfrom,
1120                                 $userto,
1121                                 $canreply
1122                             );
1124                         if (!isset($userto->viewfullnames[$forum->id])) {
1125                             $data->viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
1126                         } else {
1127                             $data->viewfullnames = $userto->viewfullnames[$forum->id];
1128                         }
1130                         if ($maildigest == 2) {
1131                             // Subjects and link only.
1132                             $posttext .= $textdigestbasicout->render($data);
1133                             $posthtml .= $htmldigestbasicout->render($data);
1134                         } else {
1135                             // The full treatment.
1136                             $posttext .= $textdigestfullout->render($data);
1137                             $posthtml .= $htmldigestfullout->render($data);
1139                             // Create an array of postid's for this user to mark as read.
1140                             if (!$CFG->forum_usermarksread) {
1141                                 $userto->markposts[$post->id] = $post->id;
1142                             }
1143                         }
1144                     }
1145                     $footerlinks = array();
1146                     if ($canunsubscribe) {
1147                         $footerlinks[] = "<a href=\"$CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id\">" . get_string("unsubscribe", "forum") . "</a>";
1148                     } else {
1149                         $footerlinks[] = get_string("everyoneissubscribed", "forum");
1150                     }
1151                     $footerlinks[] = "<a href='{$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}'>" . get_string("digestmailpost", "forum") . '</a>';
1152                     $posthtml .= "\n<div class='mdl-right'><font size=\"1\">" . implode('&nbsp;', $footerlinks) . '</font></div>';
1153                     $posthtml .= '<hr size="1" noshade="noshade" /></p>';
1154                 }
1155                 $posthtml .= '</body>';
1157                 if (empty($userto->mailformat) || $userto->mailformat != 1) {
1158                     // This user DOESN'T want to receive HTML
1159                     $posthtml = '';
1160                 }
1162                 $attachment = $attachname='';
1163                 // Directly email forum digests rather than sending them via messaging, use the
1164                 // site shortname as 'from name', the noreply address will be used by email_to_user.
1165                 $mailresult = email_to_user($userto, $site->shortname, $postsubject, $posttext, $posthtml, $attachment, $attachname);
1167                 if (!$mailresult) {
1168                     mtrace("ERROR: mod/forum/cron.php: Could not send out digest mail to user $userto->id ".
1169                         "($userto->email)... not trying again.");
1170                 } else {
1171                     mtrace("success.");
1172                     $usermailcount++;
1174                     // Mark post as read if forum_usermarksread is set off
1175                     forum_tp_mark_posts_read($userto, $userto->markposts);
1176                 }
1177             }
1178         }
1179     /// We have finishied all digest emails, update $CFG->digestmailtimelast
1180         set_config('digestmailtimelast', $timenow);
1181     }
1183     cron_setup_user();
1185     if (!empty($usermailcount)) {
1186         mtrace(get_string('digestsentusers', 'forum', $usermailcount));
1187     }
1189     if (!empty($CFG->forum_lastreadclean)) {
1190         $timenow = time();
1191         if ($CFG->forum_lastreadclean + (24*3600) < $timenow) {
1192             set_config('forum_lastreadclean', $timenow);
1193             mtrace('Removing old forum read tracking info...');
1194             forum_tp_clean_read_records();
1195         }
1196     } else {
1197         set_config('forum_lastreadclean', time());
1198     }
1200     return true;
1203 /**
1204  *
1205  * @param object $course
1206  * @param object $user
1207  * @param object $mod TODO this is not used in this function, refactor
1208  * @param object $forum
1209  * @return object A standard object with 2 variables: info (number of posts for this user) and time (last modified)
1210  */
1211 function forum_user_outline($course, $user, $mod, $forum) {
1212     global $CFG;
1213     require_once("$CFG->libdir/gradelib.php");
1214     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1215     if (empty($grades->items[0]->grades)) {
1216         $grade = false;
1217     } else {
1218         $grade = reset($grades->items[0]->grades);
1219     }
1221     $count = forum_count_user_posts($forum->id, $user->id);
1223     if ($count && $count->postcount > 0) {
1224         $result = new stdClass();
1225         $result->info = get_string("numposts", "forum", $count->postcount);
1226         $result->time = $count->lastpost;
1227         if ($grade) {
1228             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1229         }
1230         return $result;
1231     } else if ($grade) {
1232         $result = new stdClass();
1233         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1235         //datesubmitted == time created. dategraded == time modified or time overridden
1236         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1237         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1238         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1239             $result->time = $grade->dategraded;
1240         } else {
1241             $result->time = $grade->datesubmitted;
1242         }
1244         return $result;
1245     }
1246     return NULL;
1250 /**
1251  * @global object
1252  * @global object
1253  * @param object $coure
1254  * @param object $user
1255  * @param object $mod
1256  * @param object $forum
1257  */
1258 function forum_user_complete($course, $user, $mod, $forum) {
1259     global $CFG,$USER, $OUTPUT;
1260     require_once("$CFG->libdir/gradelib.php");
1262     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1263     if (!empty($grades->items[0]->grades)) {
1264         $grade = reset($grades->items[0]->grades);
1265         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1266         if ($grade->str_feedback) {
1267             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1268         }
1269     }
1271     if ($posts = forum_get_user_posts($forum->id, $user->id)) {
1273         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $course->id)) {
1274             print_error('invalidcoursemodule');
1275         }
1276         $discussions = forum_get_user_involved_discussions($forum->id, $user->id);
1278         foreach ($posts as $post) {
1279             if (!isset($discussions[$post->discussion])) {
1280                 continue;
1281             }
1282             $discussion = $discussions[$post->discussion];
1284             forum_print_post($post, $discussion, $forum, $cm, $course, false, false, false);
1285         }
1286     } else {
1287         echo "<p>".get_string("noposts", "forum")."</p>";
1288     }
1291 /**
1292  * Filters the forum discussions according to groups membership and config.
1293  *
1294  * @since  Moodle 2.8, 2.7.1, 2.6.4
1295  * @param  array $discussions Discussions with new posts array
1296  * @return array Forums with the number of new posts
1297  */
1298 function forum_filter_user_groups_discussions($discussions) {
1300     // Group the remaining discussions posts by their forumid.
1301     $filteredforums = array();
1303     // Discard not visible groups.
1304     foreach ($discussions as $discussion) {
1306         // Course data is already cached.
1307         $instances = get_fast_modinfo($discussion->course)->get_instances();
1308         $forum = $instances['forum'][$discussion->forum];
1310         // Continue if the user should not see this discussion.
1311         if (!forum_is_user_group_discussion($forum, $discussion->groupid)) {
1312             continue;
1313         }
1315         // Grouping results by forum.
1316         if (empty($filteredforums[$forum->instance])) {
1317             $filteredforums[$forum->instance] = new stdClass();
1318             $filteredforums[$forum->instance]->id = $forum->id;
1319             $filteredforums[$forum->instance]->count = 0;
1320         }
1321         $filteredforums[$forum->instance]->count += $discussion->count;
1323     }
1325     return $filteredforums;
1328 /**
1329  * Returns whether the discussion group is visible by the current user or not.
1330  *
1331  * @since Moodle 2.8, 2.7.1, 2.6.4
1332  * @param cm_info $cm The discussion course module
1333  * @param int $discussiongroupid The discussion groupid
1334  * @return bool
1335  */
1336 function forum_is_user_group_discussion(cm_info $cm, $discussiongroupid) {
1338     if ($discussiongroupid == -1 || $cm->effectivegroupmode != SEPARATEGROUPS) {
1339         return true;
1340     }
1342     if (isguestuser()) {
1343         return false;
1344     }
1346     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id)) ||
1347             in_array($discussiongroupid, $cm->get_modinfo()->get_groups($cm->groupingid))) {
1348         return true;
1349     }
1351     return false;
1354 /**
1355  * @global object
1356  * @global object
1357  * @global object
1358  * @param array $courses
1359  * @param array $htmlarray
1360  */
1361 function forum_print_overview($courses,&$htmlarray) {
1362     global $USER, $CFG, $DB, $SESSION;
1364     if (empty($courses) || !is_array($courses) || count($courses) == 0) {
1365         return array();
1366     }
1368     if (!$forums = get_all_instances_in_courses('forum',$courses)) {
1369         return;
1370     }
1372     // Courses to search for new posts
1373     $coursessqls = array();
1374     $params = array();
1375     foreach ($courses as $course) {
1377         // If the user has never entered into the course all posts are pending
1378         if ($course->lastaccess == 0) {
1379             $coursessqls[] = '(d.course = ?)';
1380             $params[] = $course->id;
1382         // Only posts created after the course last access
1383         } else {
1384             $coursessqls[] = '(d.course = ? AND p.created > ?)';
1385             $params[] = $course->id;
1386             $params[] = $course->lastaccess;
1387         }
1388     }
1389     $params[] = $USER->id;
1390     $coursessql = implode(' OR ', $coursessqls);
1392     $sql = "SELECT d.id, d.forum, d.course, d.groupid, COUNT(*) as count "
1393                 .'FROM {forum_discussions} d '
1394                 .'JOIN {forum_posts} p ON p.discussion = d.id '
1395                 ."WHERE ($coursessql) "
1396                 .'AND p.userid != ? '
1397                 .'GROUP BY d.id, d.forum, d.course, d.groupid '
1398                 .'ORDER BY d.course, d.forum';
1400     // Avoid warnings.
1401     if (!$discussions = $DB->get_records_sql($sql, $params)) {
1402         $discussions = array();
1403     }
1405     $forumsnewposts = forum_filter_user_groups_discussions($discussions);
1407     // also get all forum tracking stuff ONCE.
1408     $trackingforums = array();
1409     foreach ($forums as $forum) {
1410         if (forum_tp_can_track_forums($forum)) {
1411             $trackingforums[$forum->id] = $forum;
1412         }
1413     }
1415     if (count($trackingforums) > 0) {
1416         $cutoffdate = isset($CFG->forum_oldpostdays) ? (time() - ($CFG->forum_oldpostdays*24*60*60)) : 0;
1417         $sql = 'SELECT d.forum,d.course,COUNT(p.id) AS count '.
1418             ' FROM {forum_posts} p '.
1419             ' JOIN {forum_discussions} d ON p.discussion = d.id '.
1420             ' LEFT JOIN {forum_read} r ON r.postid = p.id AND r.userid = ? WHERE (';
1421         $params = array($USER->id);
1423         foreach ($trackingforums as $track) {
1424             $sql .= '(d.forum = ? AND (d.groupid = -1 OR d.groupid = 0 OR d.groupid = ?)) OR ';
1425             $params[] = $track->id;
1426             if (isset($SESSION->currentgroup[$track->course])) {
1427                 $groupid =  $SESSION->currentgroup[$track->course];
1428             } else {
1429                 // get first groupid
1430                 $groupids = groups_get_all_groups($track->course, $USER->id);
1431                 if ($groupids) {
1432                     reset($groupids);
1433                     $groupid = key($groupids);
1434                     $SESSION->currentgroup[$track->course] = $groupid;
1435                 } else {
1436                     $groupid = 0;
1437                 }
1438                 unset($groupids);
1439             }
1440             $params[] = $groupid;
1441         }
1442         $sql = substr($sql,0,-3); // take off the last OR
1443         $sql .= ') AND p.modified >= ? AND r.id is NULL GROUP BY d.forum,d.course';
1444         $params[] = $cutoffdate;
1446         if (!$unread = $DB->get_records_sql($sql, $params)) {
1447             $unread = array();
1448         }
1449     } else {
1450         $unread = array();
1451     }
1453     if (empty($unread) and empty($forumsnewposts)) {
1454         return;
1455     }
1457     $strforum = get_string('modulename','forum');
1459     foreach ($forums as $forum) {
1460         $str = '';
1461         $count = 0;
1462         $thisunread = 0;
1463         $showunread = false;
1464         // either we have something from logs, or trackposts, or nothing.
1465         if (array_key_exists($forum->id, $forumsnewposts) && !empty($forumsnewposts[$forum->id])) {
1466             $count = $forumsnewposts[$forum->id]->count;
1467         }
1468         if (array_key_exists($forum->id,$unread)) {
1469             $thisunread = $unread[$forum->id]->count;
1470             $showunread = true;
1471         }
1472         if ($count > 0 || $thisunread > 0) {
1473             $str .= '<div class="overview forum"><div class="name">'.$strforum.': <a title="'.$strforum.'" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.
1474                 $forum->name.'</a></div>';
1475             $str .= '<div class="info"><span class="postsincelogin">';
1476             $str .= get_string('overviewnumpostssince', 'forum', $count)."</span>";
1477             if (!empty($showunread)) {
1478                 $str .= '<div class="unreadposts">'.get_string('overviewnumunread', 'forum', $thisunread).'</div>';
1479             }
1480             $str .= '</div></div>';
1481         }
1482         if (!empty($str)) {
1483             if (!array_key_exists($forum->course,$htmlarray)) {
1484                 $htmlarray[$forum->course] = array();
1485             }
1486             if (!array_key_exists('forum',$htmlarray[$forum->course])) {
1487                 $htmlarray[$forum->course]['forum'] = ''; // initialize, avoid warnings
1488             }
1489             $htmlarray[$forum->course]['forum'] .= $str;
1490         }
1491     }
1494 /**
1495  * Given a course and a date, prints a summary of all the new
1496  * messages posted in the course since that date
1497  *
1498  * @global object
1499  * @global object
1500  * @global object
1501  * @uses CONTEXT_MODULE
1502  * @uses VISIBLEGROUPS
1503  * @param object $course
1504  * @param bool $viewfullnames capability
1505  * @param int $timestart
1506  * @return bool success
1507  */
1508 function forum_print_recent_activity($course, $viewfullnames, $timestart) {
1509     global $CFG, $USER, $DB, $OUTPUT;
1511     // do not use log table if possible, it may be huge and is expensive to join with other tables
1513     $allnamefields = user_picture::fields('u', null, 'duserid');
1514     if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
1515                                               d.timestart, d.timeend, $allnamefields
1516                                          FROM {forum_posts} p
1517                                               JOIN {forum_discussions} d ON d.id = p.discussion
1518                                               JOIN {forum} f             ON f.id = d.forum
1519                                               JOIN {user} u              ON u.id = p.userid
1520                                         WHERE p.created > ? AND f.course = ?
1521                                      ORDER BY p.id ASC", array($timestart, $course->id))) { // order by initial posting date
1522          return false;
1523     }
1525     $modinfo = get_fast_modinfo($course);
1527     $groupmodes = array();
1528     $cms    = array();
1530     $strftimerecent = get_string('strftimerecent');
1532     $printposts = array();
1533     foreach ($posts as $post) {
1534         if (!isset($modinfo->instances['forum'][$post->forum])) {
1535             // not visible
1536             continue;
1537         }
1538         $cm = $modinfo->instances['forum'][$post->forum];
1539         if (!$cm->uservisible) {
1540             continue;
1541         }
1542         $context = context_module::instance($cm->id);
1544         if (!has_capability('mod/forum:viewdiscussion', $context)) {
1545             continue;
1546         }
1548         if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
1549           and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
1550             if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1551                 continue;
1552             }
1553         }
1555         // Check that the user can see the discussion.
1556         if (forum_is_user_group_discussion($cm, $post->groupid)) {
1557             $printposts[] = $post;
1558         }
1560     }
1561     unset($posts);
1563     if (!$printposts) {
1564         return false;
1565     }
1567     echo $OUTPUT->heading(get_string('newforumposts', 'forum').':', 3);
1568     echo "\n<ul class='unlist'>\n";
1570     foreach ($printposts as $post) {
1571         $subjectclass = empty($post->parent) ? ' bold' : '';
1573         echo '<li><div class="head">'.
1574                '<div class="date">'.userdate($post->modified, $strftimerecent).'</div>'.
1575                '<div class="name">'.fullname($post, $viewfullnames).'</div>'.
1576              '</div>';
1577         echo '<div class="info'.$subjectclass.'">';
1578         if (empty($post->parent)) {
1579             echo '"<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
1580         } else {
1581             echo '"<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'&amp;parent='.$post->parent.'#p'.$post->id.'">';
1582         }
1583         $post->subject = break_up_long_words(format_string($post->subject, true));
1584         echo $post->subject;
1585         echo "</a>\"</div></li>\n";
1586     }
1588     echo "</ul>\n";
1590     return true;
1593 /**
1594  * Return grade for given user or all users.
1595  *
1596  * @global object
1597  * @global object
1598  * @param object $forum
1599  * @param int $userid optional user id, 0 means all users
1600  * @return array array of grades, false if none
1601  */
1602 function forum_get_user_grades($forum, $userid = 0) {
1603     global $CFG;
1605     require_once($CFG->dirroot.'/rating/lib.php');
1607     $ratingoptions = new stdClass;
1608     $ratingoptions->component = 'mod_forum';
1609     $ratingoptions->ratingarea = 'post';
1611     //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?
1612     $ratingoptions->modulename = 'forum';
1613     $ratingoptions->moduleid   = $forum->id;
1614     $ratingoptions->userid = $userid;
1615     $ratingoptions->aggregationmethod = $forum->assessed;
1616     $ratingoptions->scaleid = $forum->scale;
1617     $ratingoptions->itemtable = 'forum_posts';
1618     $ratingoptions->itemtableusercolumn = 'userid';
1620     $rm = new rating_manager();
1621     return $rm->get_user_grades($ratingoptions);
1624 /**
1625  * Update activity grades
1626  *
1627  * @category grade
1628  * @param object $forum
1629  * @param int $userid specific user only, 0 means all
1630  * @param boolean $nullifnone return null if grade does not exist
1631  * @return void
1632  */
1633 function forum_update_grades($forum, $userid=0, $nullifnone=true) {
1634     global $CFG, $DB;
1635     require_once($CFG->libdir.'/gradelib.php');
1637     if (!$forum->assessed) {
1638         forum_grade_item_update($forum);
1640     } else if ($grades = forum_get_user_grades($forum, $userid)) {
1641         forum_grade_item_update($forum, $grades);
1643     } else if ($userid and $nullifnone) {
1644         $grade = new stdClass();
1645         $grade->userid   = $userid;
1646         $grade->rawgrade = NULL;
1647         forum_grade_item_update($forum, $grade);
1649     } else {
1650         forum_grade_item_update($forum);
1651     }
1654 /**
1655  * Create/update grade item for given forum
1656  *
1657  * @category grade
1658  * @uses GRADE_TYPE_NONE
1659  * @uses GRADE_TYPE_VALUE
1660  * @uses GRADE_TYPE_SCALE
1661  * @param stdClass $forum Forum object with extra cmidnumber
1662  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1663  * @return int 0 if ok
1664  */
1665 function forum_grade_item_update($forum, $grades=NULL) {
1666     global $CFG;
1667     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
1668         require_once($CFG->libdir.'/gradelib.php');
1669     }
1671     $params = array('itemname'=>$forum->name, 'idnumber'=>$forum->cmidnumber);
1673     if (!$forum->assessed or $forum->scale == 0) {
1674         $params['gradetype'] = GRADE_TYPE_NONE;
1676     } else if ($forum->scale > 0) {
1677         $params['gradetype'] = GRADE_TYPE_VALUE;
1678         $params['grademax']  = $forum->scale;
1679         $params['grademin']  = 0;
1681     } else if ($forum->scale < 0) {
1682         $params['gradetype'] = GRADE_TYPE_SCALE;
1683         $params['scaleid']   = -$forum->scale;
1684     }
1686     if ($grades  === 'reset') {
1687         $params['reset'] = true;
1688         $grades = NULL;
1689     }
1691     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, $grades, $params);
1694 /**
1695  * Delete grade item for given forum
1696  *
1697  * @category grade
1698  * @param stdClass $forum Forum object
1699  * @return grade_item
1700  */
1701 function forum_grade_item_delete($forum) {
1702     global $CFG;
1703     require_once($CFG->libdir.'/gradelib.php');
1705     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, NULL, array('deleted'=>1));
1709 /**
1710  * This function returns if a scale is being used by one forum
1711  *
1712  * @global object
1713  * @param int $forumid
1714  * @param int $scaleid negative number
1715  * @return bool
1716  */
1717 function forum_scale_used ($forumid,$scaleid) {
1718     global $DB;
1719     $return = false;
1721     $rec = $DB->get_record("forum",array("id" => "$forumid","scale" => "-$scaleid"));
1723     if (!empty($rec) && !empty($scaleid)) {
1724         $return = true;
1725     }
1727     return $return;
1730 /**
1731  * Checks if scale is being used by any instance of forum
1732  *
1733  * This is used to find out if scale used anywhere
1734  *
1735  * @global object
1736  * @param $scaleid int
1737  * @return boolean True if the scale is used by any forum
1738  */
1739 function forum_scale_used_anywhere($scaleid) {
1740     global $DB;
1741     if ($scaleid and $DB->record_exists('forum', array('scale' => -$scaleid))) {
1742         return true;
1743     } else {
1744         return false;
1745     }
1748 // SQL FUNCTIONS ///////////////////////////////////////////////////////////
1750 /**
1751  * Gets a post with all info ready for forum_print_post
1752  * Most of these joins are just to get the forum id
1753  *
1754  * @global object
1755  * @global object
1756  * @param int $postid
1757  * @return mixed array of posts or false
1758  */
1759 function forum_get_post_full($postid) {
1760     global $CFG, $DB;
1762     $allnames = get_all_user_name_fields(true, 'u');
1763     return $DB->get_record_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1764                              FROM {forum_posts} p
1765                                   JOIN {forum_discussions} d ON p.discussion = d.id
1766                                   LEFT JOIN {user} u ON p.userid = u.id
1767                             WHERE p.id = ?", array($postid));
1770 /**
1771  * Gets all posts in discussion including top parent.
1772  *
1773  * @global object
1774  * @global object
1775  * @global object
1776  * @param int $discussionid
1777  * @param string $sort
1778  * @param bool $tracking does user track the forum?
1779  * @return array of posts
1780  */
1781 function forum_get_all_discussion_posts($discussionid, $sort, $tracking=false) {
1782     global $CFG, $DB, $USER;
1784     $tr_sel  = "";
1785     $tr_join = "";
1786     $params = array();
1788     if ($tracking) {
1789         $now = time();
1790         $cutoffdate = $now - ($CFG->forum_oldpostdays * 24 * 3600);
1791         $tr_sel  = ", fr.id AS postread";
1792         $tr_join = "LEFT JOIN {forum_read} fr ON (fr.postid = p.id AND fr.userid = ?)";
1793         $params[] = $USER->id;
1794     }
1796     $allnames = get_all_user_name_fields(true, 'u');
1797     $params[] = $discussionid;
1798     if (!$posts = $DB->get_records_sql("SELECT p.*, $allnames, u.email, u.picture, u.imagealt $tr_sel
1799                                      FROM {forum_posts} p
1800                                           LEFT JOIN {user} u ON p.userid = u.id
1801                                           $tr_join
1802                                     WHERE p.discussion = ?
1803                                  ORDER BY $sort", $params)) {
1804         return array();
1805     }
1807     foreach ($posts as $pid=>$p) {
1808         if ($tracking) {
1809             if (forum_tp_is_post_old($p)) {
1810                  $posts[$pid]->postread = true;
1811             }
1812         }
1813         if (!$p->parent) {
1814             continue;
1815         }
1816         if (!isset($posts[$p->parent])) {
1817             continue; // parent does not exist??
1818         }
1819         if (!isset($posts[$p->parent]->children)) {
1820             $posts[$p->parent]->children = array();
1821         }
1822         $posts[$p->parent]->children[$pid] =& $posts[$pid];
1823     }
1825     // Start with the last child of the first post.
1826     $post = &$posts[reset($posts)->id];
1828     $lastpost = false;
1829     while (!$lastpost) {
1830         if (!isset($post->children)) {
1831             $post->lastpost = true;
1832             $lastpost = true;
1833         } else {
1834              // Go to the last child of this post.
1835             $post = &$posts[end($post->children)->id];
1836         }
1837     }
1839     return $posts;
1842 /**
1843  * An array of forum objects that the user is allowed to read/search through.
1844  *
1845  * @global object
1846  * @global object
1847  * @global object
1848  * @param int $userid
1849  * @param int $courseid if 0, we look for forums throughout the whole site.
1850  * @return array of forum objects, or false if no matches
1851  *         Forum objects have the following attributes:
1852  *         id, type, course, cmid, cmvisible, cmgroupmode, accessallgroups,
1853  *         viewhiddentimedposts
1854  */
1855 function forum_get_readable_forums($userid, $courseid=0) {
1857     global $CFG, $DB, $USER;
1858     require_once($CFG->dirroot.'/course/lib.php');
1860     if (!$forummod = $DB->get_record('modules', array('name' => 'forum'))) {
1861         print_error('notinstalled', 'forum');
1862     }
1864     if ($courseid) {
1865         $courses = $DB->get_records('course', array('id' => $courseid));
1866     } else {
1867         // If no course is specified, then the user can see SITE + his courses.
1868         $courses1 = $DB->get_records('course', array('id' => SITEID));
1869         $courses2 = enrol_get_users_courses($userid, true, array('modinfo'));
1870         $courses = array_merge($courses1, $courses2);
1871     }
1872     if (!$courses) {
1873         return array();
1874     }
1876     $readableforums = array();
1878     foreach ($courses as $course) {
1880         $modinfo = get_fast_modinfo($course);
1882         if (empty($modinfo->instances['forum'])) {
1883             // hmm, no forums?
1884             continue;
1885         }
1887         $courseforums = $DB->get_records('forum', array('course' => $course->id));
1889         foreach ($modinfo->instances['forum'] as $forumid => $cm) {
1890             if (!$cm->uservisible or !isset($courseforums[$forumid])) {
1891                 continue;
1892             }
1893             $context = context_module::instance($cm->id);
1894             $forum = $courseforums[$forumid];
1895             $forum->context = $context;
1896             $forum->cm = $cm;
1898             if (!has_capability('mod/forum:viewdiscussion', $context)) {
1899                 continue;
1900             }
1902          /// group access
1903             if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
1905                 $forum->onlygroups = $modinfo->get_groups($cm->groupingid);
1906                 $forum->onlygroups[] = -1;
1907             }
1909         /// hidden timed discussions
1910             $forum->viewhiddentimedposts = true;
1911             if (!empty($CFG->forum_enabletimedposts)) {
1912                 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1913                     $forum->viewhiddentimedposts = false;
1914                 }
1915             }
1917         /// qanda access
1918             if ($forum->type == 'qanda'
1919                     && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
1921                 // We need to check whether the user has posted in the qanda forum.
1922                 $forum->onlydiscussions = array();  // Holds discussion ids for the discussions
1923                                                     // the user is allowed to see in this forum.
1924                 if ($discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $USER->id)) {
1925                     foreach ($discussionspostedin as $d) {
1926                         $forum->onlydiscussions[] = $d->id;
1927                     }
1928                 }
1929             }
1931             $readableforums[$forum->id] = $forum;
1932         }
1934         unset($modinfo);
1936     } // End foreach $courses
1938     return $readableforums;
1941 /**
1942  * Returns a list of posts found using an array of search terms.
1943  *
1944  * @global object
1945  * @global object
1946  * @global object
1947  * @param array $searchterms array of search terms, e.g. word +word -word
1948  * @param int $courseid if 0, we search through the whole site
1949  * @param int $limitfrom
1950  * @param int $limitnum
1951  * @param int &$totalcount
1952  * @param string $extrasql
1953  * @return array|bool Array of posts found or false
1954  */
1955 function forum_search_posts($searchterms, $courseid=0, $limitfrom=0, $limitnum=50,
1956                             &$totalcount, $extrasql='') {
1957     global $CFG, $DB, $USER;
1958     require_once($CFG->libdir.'/searchlib.php');
1960     $forums = forum_get_readable_forums($USER->id, $courseid);
1962     if (count($forums) == 0) {
1963         $totalcount = 0;
1964         return false;
1965     }
1967     $now = round(time(), -2); // db friendly
1969     $fullaccess = array();
1970     $where = array();
1971     $params = array();
1973     foreach ($forums as $forumid => $forum) {
1974         $select = array();
1976         if (!$forum->viewhiddentimedposts) {
1977             $select[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
1978             $params = array_merge($params, array('userid'.$forumid=>$USER->id, 'timestart'.$forumid=>$now, 'timeend'.$forumid=>$now));
1979         }
1981         $cm = $forum->cm;
1982         $context = $forum->context;
1984         if ($forum->type == 'qanda'
1985             && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
1986             if (!empty($forum->onlydiscussions)) {
1987                 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forum->onlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
1988                 $params = array_merge($params, $discussionid_params);
1989                 $select[] = "(d.id $discussionid_sql OR p.parent = 0)";
1990             } else {
1991                 $select[] = "p.parent = 0";
1992             }
1993         }
1995         if (!empty($forum->onlygroups)) {
1996             list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($forum->onlygroups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
1997             $params = array_merge($params, $groupid_params);
1998             $select[] = "d.groupid $groupid_sql";
1999         }
2001         if ($select) {
2002             $selects = implode(" AND ", $select);
2003             $where[] = "(d.forum = :forum{$forumid} AND $selects)";
2004             $params['forum'.$forumid] = $forumid;
2005         } else {
2006             $fullaccess[] = $forumid;
2007         }
2008     }
2010     if ($fullaccess) {
2011         list($fullid_sql, $fullid_params) = $DB->get_in_or_equal($fullaccess, SQL_PARAMS_NAMED, 'fula');
2012         $params = array_merge($params, $fullid_params);
2013         $where[] = "(d.forum $fullid_sql)";
2014     }
2016     $selectdiscussion = "(".implode(" OR ", $where).")";
2018     $messagesearch = '';
2019     $searchstring = '';
2021     // Need to concat these back together for parser to work.
2022     foreach($searchterms as $searchterm){
2023         if ($searchstring != '') {
2024             $searchstring .= ' ';
2025         }
2026         $searchstring .= $searchterm;
2027     }
2029     // We need to allow quoted strings for the search. The quotes *should* be stripped
2030     // by the parser, but this should be examined carefully for security implications.
2031     $searchstring = str_replace("\\\"","\"",$searchstring);
2032     $parser = new search_parser();
2033     $lexer = new search_lexer($parser);
2035     if ($lexer->parse($searchstring)) {
2036         $parsearray = $parser->get_parsed_array();
2037         list($messagesearch, $msparams) = search_generate_SQL($parsearray, 'p.message', 'p.subject',
2038                                                               'p.userid', 'u.id', 'u.firstname',
2039                                                               'u.lastname', 'p.modified', 'd.forum');
2040         $params = array_merge($params, $msparams);
2041     }
2043     $fromsql = "{forum_posts} p,
2044                   {forum_discussions} d,
2045                   {user} u";
2047     $selectsql = " $messagesearch
2048                AND p.discussion = d.id
2049                AND p.userid = u.id
2050                AND $selectdiscussion
2051                    $extrasql";
2053     $countsql = "SELECT COUNT(*)
2054                    FROM $fromsql
2055                   WHERE $selectsql";
2057     $allnames = get_all_user_name_fields(true, 'u');
2058     $searchsql = "SELECT p.*,
2059                          d.forum,
2060                          $allnames,
2061                          u.email,
2062                          u.picture,
2063                          u.imagealt
2064                     FROM $fromsql
2065                    WHERE $selectsql
2066                 ORDER BY p.modified DESC";
2068     $totalcount = $DB->count_records_sql($countsql, $params);
2070     return $DB->get_records_sql($searchsql, $params, $limitfrom, $limitnum);
2073 /**
2074  * Returns a list of all new posts that have not been mailed yet
2075  *
2076  * @param int $starttime posts created after this time
2077  * @param int $endtime posts created before this
2078  * @param int $now used for timed discussions only
2079  * @return array
2080  */
2081 function forum_get_unmailed_posts($starttime, $endtime, $now=null) {
2082     global $CFG, $DB;
2084     $params = array();
2085     $params['mailed'] = FORUM_MAILED_PENDING;
2086     $params['ptimestart'] = $starttime;
2087     $params['ptimeend'] = $endtime;
2088     $params['mailnow'] = 1;
2090     if (!empty($CFG->forum_enabletimedposts)) {
2091         if (empty($now)) {
2092             $now = time();
2093         }
2094         $timedsql = "AND (d.timestart < :dtimestart AND (d.timeend = 0 OR d.timeend > :dtimeend))";
2095         $params['dtimestart'] = $now;
2096         $params['dtimeend'] = $now;
2097     } else {
2098         $timedsql = "";
2099     }
2101     return $DB->get_records_sql("SELECT p.*, d.course, d.forum
2102                                  FROM {forum_posts} p
2103                                  JOIN {forum_discussions} d ON d.id = p.discussion
2104                                  WHERE p.mailed = :mailed
2105                                  AND p.created >= :ptimestart
2106                                  AND (p.created < :ptimeend OR p.mailnow = :mailnow)
2107                                  $timedsql
2108                                  ORDER BY p.modified ASC", $params);
2111 /**
2112  * Marks posts before a certain time as being mailed already
2113  *
2114  * @global object
2115  * @global object
2116  * @param int $endtime
2117  * @param int $now Defaults to time()
2118  * @return bool
2119  */
2120 function forum_mark_old_posts_as_mailed($endtime, $now=null) {
2121     global $CFG, $DB;
2123     if (empty($now)) {
2124         $now = time();
2125     }
2127     $params = array();
2128     $params['mailedsuccess'] = FORUM_MAILED_SUCCESS;
2129     $params['now'] = $now;
2130     $params['endtime'] = $endtime;
2131     $params['mailnow'] = 1;
2132     $params['mailedpending'] = FORUM_MAILED_PENDING;
2134     if (empty($CFG->forum_enabletimedposts)) {
2135         return $DB->execute("UPDATE {forum_posts}
2136                              SET mailed = :mailedsuccess
2137                              WHERE (created < :endtime OR mailnow = :mailnow)
2138                              AND mailed = :mailedpending", $params);
2139     } else {
2140         return $DB->execute("UPDATE {forum_posts}
2141                              SET mailed = :mailedsuccess
2142                              WHERE discussion NOT IN (SELECT d.id
2143                                                       FROM {forum_discussions} d
2144                                                       WHERE d.timestart > :now)
2145                              AND (created < :endtime OR mailnow = :mailnow)
2146                              AND mailed = :mailedpending", $params);
2147     }
2150 /**
2151  * Get all the posts for a user in a forum suitable for forum_print_post
2152  *
2153  * @global object
2154  * @global object
2155  * @uses CONTEXT_MODULE
2156  * @return array
2157  */
2158 function forum_get_user_posts($forumid, $userid) {
2159     global $CFG, $DB;
2161     $timedsql = "";
2162     $params = array($forumid, $userid);
2164     if (!empty($CFG->forum_enabletimedposts)) {
2165         $cm = get_coursemodule_from_instance('forum', $forumid);
2166         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2167             $now = time();
2168             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2169             $params[] = $now;
2170             $params[] = $now;
2171         }
2172     }
2174     $allnames = get_all_user_name_fields(true, 'u');
2175     return $DB->get_records_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
2176                               FROM {forum} f
2177                                    JOIN {forum_discussions} d ON d.forum = f.id
2178                                    JOIN {forum_posts} p       ON p.discussion = d.id
2179                                    JOIN {user} u              ON u.id = p.userid
2180                              WHERE f.id = ?
2181                                    AND p.userid = ?
2182                                    $timedsql
2183                           ORDER BY p.modified ASC", $params);
2186 /**
2187  * Get all the discussions user participated in
2188  *
2189  * @global object
2190  * @global object
2191  * @uses CONTEXT_MODULE
2192  * @param int $forumid
2193  * @param int $userid
2194  * @return array Array or false
2195  */
2196 function forum_get_user_involved_discussions($forumid, $userid) {
2197     global $CFG, $DB;
2199     $timedsql = "";
2200     $params = array($forumid, $userid);
2201     if (!empty($CFG->forum_enabletimedposts)) {
2202         $cm = get_coursemodule_from_instance('forum', $forumid);
2203         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2204             $now = time();
2205             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2206             $params[] = $now;
2207             $params[] = $now;
2208         }
2209     }
2211     return $DB->get_records_sql("SELECT DISTINCT d.*
2212                               FROM {forum} f
2213                                    JOIN {forum_discussions} d ON d.forum = f.id
2214                                    JOIN {forum_posts} p       ON p.discussion = d.id
2215                              WHERE f.id = ?
2216                                    AND p.userid = ?
2217                                    $timedsql", $params);
2220 /**
2221  * Get all the posts for a user in a forum suitable for forum_print_post
2222  *
2223  * @global object
2224  * @global object
2225  * @param int $forumid
2226  * @param int $userid
2227  * @return array of counts or false
2228  */
2229 function forum_count_user_posts($forumid, $userid) {
2230     global $CFG, $DB;
2232     $timedsql = "";
2233     $params = array($forumid, $userid);
2234     if (!empty($CFG->forum_enabletimedposts)) {
2235         $cm = get_coursemodule_from_instance('forum', $forumid);
2236         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2237             $now = time();
2238             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2239             $params[] = $now;
2240             $params[] = $now;
2241         }
2242     }
2244     return $DB->get_record_sql("SELECT COUNT(p.id) AS postcount, MAX(p.modified) AS lastpost
2245                              FROM {forum} f
2246                                   JOIN {forum_discussions} d ON d.forum = f.id
2247                                   JOIN {forum_posts} p       ON p.discussion = d.id
2248                                   JOIN {user} u              ON u.id = p.userid
2249                             WHERE f.id = ?
2250                                   AND p.userid = ?
2251                                   $timedsql", $params);
2254 /**
2255  * Given a log entry, return the forum post details for it.
2256  *
2257  * @global object
2258  * @global object
2259  * @param object $log
2260  * @return array|null
2261  */
2262 function forum_get_post_from_log($log) {
2263     global $CFG, $DB;
2265     $allnames = get_all_user_name_fields(true, 'u');
2266     if ($log->action == "add post") {
2268         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2269                                  FROM {forum_discussions} d,
2270                                       {forum_posts} p,
2271                                       {forum} f,
2272                                       {user} u
2273                                 WHERE p.id = ?
2274                                   AND d.id = p.discussion
2275                                   AND p.userid = u.id
2276                                   AND u.deleted <> '1'
2277                                   AND f.id = d.forum", array($log->info));
2280     } else if ($log->action == "add discussion") {
2282         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2283                                  FROM {forum_discussions} d,
2284                                       {forum_posts} p,
2285                                       {forum} f,
2286                                       {user} u
2287                                 WHERE d.id = ?
2288                                   AND d.firstpost = p.id
2289                                   AND p.userid = u.id
2290                                   AND u.deleted <> '1'
2291                                   AND f.id = d.forum", array($log->info));
2292     }
2293     return NULL;
2296 /**
2297  * Given a discussion id, return the first post from the discussion
2298  *
2299  * @global object
2300  * @global object
2301  * @param int $dicsussionid
2302  * @return array
2303  */
2304 function forum_get_firstpost_from_discussion($discussionid) {
2305     global $CFG, $DB;
2307     return $DB->get_record_sql("SELECT p.*
2308                              FROM {forum_discussions} d,
2309                                   {forum_posts} p
2310                             WHERE d.id = ?
2311                               AND d.firstpost = p.id ", array($discussionid));
2314 /**
2315  * Returns an array of counts of replies to each discussion
2316  *
2317  * @global object
2318  * @global object
2319  * @param int $forumid
2320  * @param string $forumsort
2321  * @param int $limit
2322  * @param int $page
2323  * @param int $perpage
2324  * @return array
2325  */
2326 function forum_count_discussion_replies($forumid, $forumsort="", $limit=-1, $page=-1, $perpage=0) {
2327     global $CFG, $DB;
2329     if ($limit > 0) {
2330         $limitfrom = 0;
2331         $limitnum  = $limit;
2332     } else if ($page != -1) {
2333         $limitfrom = $page*$perpage;
2334         $limitnum  = $perpage;
2335     } else {
2336         $limitfrom = 0;
2337         $limitnum  = 0;
2338     }
2340     if ($forumsort == "") {
2341         $orderby = "";
2342         $groupby = "";
2344     } else {
2345         $orderby = "ORDER BY $forumsort";
2346         $groupby = ", ".strtolower($forumsort);
2347         $groupby = str_replace('desc', '', $groupby);
2348         $groupby = str_replace('asc', '', $groupby);
2349     }
2351     if (($limitfrom == 0 and $limitnum == 0) or $forumsort == "") {
2352         $sql = "SELECT p.discussion, COUNT(p.id) AS replies, MAX(p.id) AS lastpostid
2353                   FROM {forum_posts} p
2354                        JOIN {forum_discussions} d ON p.discussion = d.id
2355                  WHERE p.parent > 0 AND d.forum = ?
2356               GROUP BY p.discussion";
2357         return $DB->get_records_sql($sql, array($forumid));
2359     } else {
2360         $sql = "SELECT p.discussion, (COUNT(p.id) - 1) AS replies, MAX(p.id) AS lastpostid
2361                   FROM {forum_posts} p
2362                        JOIN {forum_discussions} d ON p.discussion = d.id
2363                  WHERE d.forum = ?
2364               GROUP BY p.discussion $groupby $orderby";
2365         return $DB->get_records_sql($sql, array($forumid), $limitfrom, $limitnum);
2366     }
2369 /**
2370  * @global object
2371  * @global object
2372  * @global object
2373  * @staticvar array $cache
2374  * @param object $forum
2375  * @param object $cm
2376  * @param object $course
2377  * @return mixed
2378  */
2379 function forum_count_discussions($forum, $cm, $course) {
2380     global $CFG, $DB, $USER;
2382     static $cache = array();
2384     $now = round(time(), -2); // db cache friendliness
2386     $params = array($course->id);
2388     if (!isset($cache[$course->id])) {
2389         if (!empty($CFG->forum_enabletimedposts)) {
2390             $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
2391             $params[] = $now;
2392             $params[] = $now;
2393         } else {
2394             $timedsql = "";
2395         }
2397         $sql = "SELECT f.id, COUNT(d.id) as dcount
2398                   FROM {forum} f
2399                        JOIN {forum_discussions} d ON d.forum = f.id
2400                  WHERE f.course = ?
2401                        $timedsql
2402               GROUP BY f.id";
2404         if ($counts = $DB->get_records_sql($sql, $params)) {
2405             foreach ($counts as $count) {
2406                 $counts[$count->id] = $count->dcount;
2407             }
2408             $cache[$course->id] = $counts;
2409         } else {
2410             $cache[$course->id] = array();
2411         }
2412     }
2414     if (empty($cache[$course->id][$forum->id])) {
2415         return 0;
2416     }
2418     $groupmode = groups_get_activity_groupmode($cm, $course);
2420     if ($groupmode != SEPARATEGROUPS) {
2421         return $cache[$course->id][$forum->id];
2422     }
2424     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
2425         return $cache[$course->id][$forum->id];
2426     }
2428     require_once($CFG->dirroot.'/course/lib.php');
2430     $modinfo = get_fast_modinfo($course);
2432     $mygroups = $modinfo->get_groups($cm->groupingid);
2434     // add all groups posts
2435     $mygroups[-1] = -1;
2437     list($mygroups_sql, $params) = $DB->get_in_or_equal($mygroups);
2438     $params[] = $forum->id;
2440     if (!empty($CFG->forum_enabletimedposts)) {
2441         $timedsql = "AND d.timestart < $now AND (d.timeend = 0 OR d.timeend > $now)";
2442         $params[] = $now;
2443         $params[] = $now;
2444     } else {
2445         $timedsql = "";
2446     }
2448     $sql = "SELECT COUNT(d.id)
2449               FROM {forum_discussions} d
2450              WHERE d.groupid $mygroups_sql AND d.forum = ?
2451                    $timedsql";
2453     return $DB->get_field_sql($sql, $params);
2456 /**
2457  * Get all discussions in a forum
2458  *
2459  * @global object
2460  * @global object
2461  * @global object
2462  * @uses CONTEXT_MODULE
2463  * @uses VISIBLEGROUPS
2464  * @param object $cm
2465  * @param string $forumsort
2466  * @param bool $fullpost
2467  * @param int $unused
2468  * @param int $limit
2469  * @param bool $userlastmodified
2470  * @param int $page
2471  * @param int $perpage
2472  * @param int $groupid if groups enabled, get discussions for this group overriding the current group.
2473  *                     Use FORUM_POSTS_ALL_USER_GROUPS for all the user groups
2474  * @return array
2475  */
2476 function forum_get_discussions($cm, $forumsort="", $fullpost=true, $unused=-1, $limit=-1,
2477                                 $userlastmodified=false, $page=-1, $perpage=0, $groupid = -1) {
2478     global $CFG, $DB, $USER;
2480     $timelimit = '';
2482     $now = round(time(), -2);
2483     $params = array($cm->instance);
2485     $modcontext = context_module::instance($cm->id);
2487     if (!has_capability('mod/forum:viewdiscussion', $modcontext)) { /// User must have perms to view discussions
2488         return array();
2489     }
2491     if (!empty($CFG->forum_enabletimedposts)) { /// Users must fulfill timed posts
2493         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2494             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2495             $params[] = $now;
2496             $params[] = $now;
2497             if (isloggedin()) {
2498                 $timelimit .= " OR d.userid = ?";
2499                 $params[] = $USER->id;
2500             }
2501             $timelimit .= ")";
2502         }
2503     }
2505     if ($limit > 0) {
2506         $limitfrom = 0;
2507         $limitnum  = $limit;
2508     } else if ($page != -1) {
2509         $limitfrom = $page*$perpage;
2510         $limitnum  = $perpage;
2511     } else {
2512         $limitfrom = 0;
2513         $limitnum  = 0;
2514     }
2516     $groupmode    = groups_get_activity_groupmode($cm);
2518     if ($groupmode) {
2520         if (empty($modcontext)) {
2521             $modcontext = context_module::instance($cm->id);
2522         }
2524         // Special case, we received a groupid to override currentgroup.
2525         if ($groupid > 0) {
2526             $course = get_course($cm->course);
2527             if (!groups_group_visible($groupid, $course, $cm)) {
2528                 // User doesn't belong to this group, return nothing.
2529                 return array();
2530             }
2531             $currentgroup = $groupid;
2532         } else if ($groupid === -1) {
2533             $currentgroup = groups_get_activity_group($cm);
2534         } else {
2535             // Get discussions for all groups current user can see.
2536             $currentgroup = null;
2537         }
2539         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2540             if ($currentgroup) {
2541                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2542                 $params[] = $currentgroup;
2543             } else {
2544                 $groupselect = "";
2545             }
2547         } else {
2548             // Separate groups.
2550             // Get discussions for all groups current user can see.
2551             if ($currentgroup === null) {
2552                 $mygroups = array_keys(groups_get_all_groups($cm->course, $USER->id, $cm->groupingid, 'g.id'));
2553                 if (empty($mygroups)) {
2554                      $groupselect = "AND d.groupid = -1";
2555                 } else {
2556                     list($insqlgroups, $inparamsgroups) = $DB->get_in_or_equal($mygroups);
2557                     $groupselect = "AND (d.groupid = -1 OR d.groupid $insqlgroups)";
2558                     $params = array_merge($params, $inparamsgroups);
2559                 }
2560             } else if ($currentgroup) {
2561                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2562                 $params[] = $currentgroup;
2563             } else {
2564                 $groupselect = "AND d.groupid = -1";
2565             }
2566         }
2567     } else {
2568         $groupselect = "";
2569     }
2570     if (empty($forumsort)) {
2571         $forumsort = forum_get_default_sort_order();
2572     }
2573     if (empty($fullpost)) {
2574         $postdata = "p.id,p.subject,p.modified,p.discussion,p.userid";
2575     } else {
2576         $postdata = "p.*";
2577     }
2579     if (empty($userlastmodified)) {  // We don't need to know this
2580         $umfields = "";
2581         $umtable  = "";
2582     } else {
2583         $umfields = ', ' . get_all_user_name_fields(true, 'um', null, 'um') . ', um.email AS umemail, um.picture AS umpicture,
2584                         um.imagealt AS umimagealt';
2585         $umtable  = " LEFT JOIN {user} um ON (d.usermodified = um.id)";
2586     }
2588     $allnames = get_all_user_name_fields(true, 'u');
2589     $sql = "SELECT $postdata, d.name, d.timemodified, d.usermodified, d.groupid, d.timestart, d.timeend, $allnames,
2590                    u.email, u.picture, u.imagealt $umfields
2591               FROM {forum_discussions} d
2592                    JOIN {forum_posts} p ON p.discussion = d.id
2593                    JOIN {user} u ON p.userid = u.id
2594                    $umtable
2595              WHERE d.forum = ? AND p.parent = 0
2596                    $timelimit $groupselect
2597           ORDER BY $forumsort";
2598     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
2601 /**
2602  * Gets the neighbours (previous and next) of a discussion.
2603  *
2604  * The calculation is based on the timemodified of the discussion and does not handle
2605  * the neighbours having an identical timemodified. The reason is that we do not have any
2606  * other mean to sort the records, e.g. we cannot use IDs as a greater ID can have a lower
2607  * timemodified.
2608  *
2609  * For blog-style forums, the calculation is based on the original creation time of the
2610  * blog post.
2611  *
2612  * Please note that this does not check whether or not the discussion passed is accessible
2613  * by the user, it simply uses it as a reference to find the neighbours. On the other hand,
2614  * the returned neighbours are checked and are accessible to the current user.
2615  *
2616  * @param object $cm The CM record.
2617  * @param object $discussion The discussion record.
2618  * @param object $forum The forum instance record.
2619  * @return array That always contains the keys 'prev' and 'next'. When there is a result
2620  *               they contain the record with minimal information such as 'id' and 'name'.
2621  *               When the neighbour is not found the value is false.
2622  */
2623 function forum_get_discussion_neighbours($cm, $discussion, $forum) {
2624     global $CFG, $DB, $USER;
2626     if ($cm->instance != $discussion->forum or $discussion->forum != $forum->id or $forum->id != $cm->instance) {
2627         throw new coding_exception('Discussion is not part of the same forum.');
2628     }
2630     $neighbours = array('prev' => false, 'next' => false);
2631     $now = round(time(), -2);
2632     $params = array();
2634     $modcontext = context_module::instance($cm->id);
2635     $groupmode    = groups_get_activity_groupmode($cm);
2636     $currentgroup = groups_get_activity_group($cm);
2638     // Users must fulfill timed posts.
2639     $timelimit = '';
2640     if (!empty($CFG->forum_enabletimedposts)) {
2641         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2642             $timelimit = ' AND ((d.timestart <= :tltimestart AND (d.timeend = 0 OR d.timeend > :tltimeend))';
2643             $params['tltimestart'] = $now;
2644             $params['tltimeend'] = $now;
2645             if (isloggedin()) {
2646                 $timelimit .= ' OR d.userid = :tluserid';
2647                 $params['tluserid'] = $USER->id;
2648             }
2649             $timelimit .= ')';
2650         }
2651     }
2653     // Limiting to posts accessible according to groups.
2654     $groupselect = '';
2655     if ($groupmode) {
2656         if ($groupmode == VISIBLEGROUPS || has_capability('moodle/site:accessallgroups', $modcontext)) {
2657             if ($currentgroup) {
2658                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2659                 $params['groupid'] = $currentgroup;
2660             }
2661         } else {
2662             if ($currentgroup) {
2663                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2664                 $params['groupid'] = $currentgroup;
2665             } else {
2666                 $groupselect = 'AND d.groupid = -1';
2667             }
2668         }
2669     }
2671     if ($forum->type === 'blog') {
2672         $params['forumid'] = $cm->instance;
2673         $params['discid1'] = $discussion->id;
2674         $params['discid2'] = $discussion->id;
2676         $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
2677                   FROM {forum_discussions} d
2678                   JOIN {forum_posts} p ON d.firstpost = p.id
2679                  WHERE d.forum = :forumid
2680                    AND d.id <> :discid1
2681                        $timelimit
2682                        $groupselect";
2684         $sub = "SELECT pp.created
2685                   FROM {forum_discussions} dd
2686                   JOIN {forum_posts} pp ON dd.firstpost = pp.id
2687                  WHERE dd.id = :discid2";
2689         $prevsql = $sql . " AND p.created < ($sub)
2690                        ORDER BY p.created DESC";
2692         $nextsql = $sql . " AND p.created > ($sub)
2693                        ORDER BY p.created ASC";
2695         $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
2696         $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
2698     } else {
2699         $params['forumid'] = $cm->instance;
2700         $params['discid'] = $discussion->id;
2701         $params['disctimemodified'] = $discussion->timemodified;
2703         $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
2704                   FROM {forum_discussions} d
2705                  WHERE d.forum = :forumid
2706                    AND d.id <> :discid
2707                        $timelimit
2708                        $groupselect";
2710         if (empty($CFG->forum_enabletimedposts)) {
2711             $prevsql = $sql . " AND d.timemodified < :disctimemodified";
2712             $nextsql = $sql . " AND d.timemodified > :disctimemodified";
2714         } else {
2715             // Normally we would just use the timemodified for sorting
2716             // discussion posts. However, when timed discussions are enabled,
2717             // then posts need to be sorted base on the later of timemodified
2718             // or the release date of the post (timestart).
2719             $params['disctimecompare'] = $discussion->timemodified;
2720             if ($discussion->timemodified < $discussion->timestart) {
2721                 $params['disctimecompare'] = $discussion->timestart;
2722             }
2724             // Here we need to take into account the release time (timestart)
2725             // if one is set, of the neighbouring posts and compare it to the
2726             // timestart or timemodified of *this* post depending on if the
2727             // release date of this post is in the future or not.
2728             // This stops discussions that appear later because of the
2729             // timestart value from being buried under discussions that were
2730             // made afterwards.
2731             $prevsql = $sql . " AND CASE WHEN d.timemodified < d.timestart
2732                                     THEN d.timestart ELSE d.timemodified END < :disctimecompare";
2733             $nextsql = $sql . " AND CASE WHEN d.timemodified < d.timestart
2734                                     THEN d.timestart ELSE d.timemodified END > :disctimecompare";
2735         }
2736         $prevsql .= ' ORDER BY '.forum_get_default_sort_order();
2737         $nextsql .= ' ORDER BY '.forum_get_default_sort_order(false);
2739         $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
2740         $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
2741     }
2743     return $neighbours;
2746 /**
2747  * Get the sql to use in the ORDER BY clause for forum discussions.
2748  *
2749  * This has the ordering take timed discussion windows into account.
2750  *
2751  * @param bool $desc True for DESC, False for ASC.
2752  * @param string $compare The field in the SQL to compare to normally sort by.
2753  * @param string $prefix The prefix being used for the discussion table.
2754  * @return string
2755  */
2756 function forum_get_default_sort_order($desc = true, $compare = 'd.timemodified', $prefix = 'd') {
2757     global $CFG;
2759     if (!empty($prefix)) {
2760         $prefix .= '.';
2761     }
2763     $dir = $desc ? 'DESC' : 'ASC';
2765     $sort = "{$prefix}timemodified";
2766     if (!empty($CFG->forum_enabletimedposts)) {
2767         $sort = "CASE WHEN {$compare} < {$prefix}timestart
2768                  THEN {$prefix}timestart
2769                  ELSE {$compare}
2770                  END";
2771     }
2772     return "$sort $dir";
2775 /**
2776  *
2777  * @global object
2778  * @global object
2779  * @global object
2780  * @uses CONTEXT_MODULE
2781  * @uses VISIBLEGROUPS
2782  * @param object $cm
2783  * @return array
2784  */
2785 function forum_get_discussions_unread($cm) {
2786     global $CFG, $DB, $USER;
2788     $now = round(time(), -2);
2789     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2791     $params = array();
2792     $groupmode    = groups_get_activity_groupmode($cm);
2793     $currentgroup = groups_get_activity_group($cm);
2795     if ($groupmode) {
2796         $modcontext = context_module::instance($cm->id);
2798         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2799             if ($currentgroup) {
2800                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2801                 $params['currentgroup'] = $currentgroup;
2802             } else {
2803                 $groupselect = "";
2804             }
2806         } else {
2807             //separate groups without access all
2808             if ($currentgroup) {
2809                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2810                 $params['currentgroup'] = $currentgroup;
2811             } else {
2812                 $groupselect = "AND d.groupid = -1";
2813             }
2814         }
2815     } else {
2816         $groupselect = "";
2817     }
2819     if (!empty($CFG->forum_enabletimedposts)) {
2820         $timedsql = "AND d.timestart < :now1 AND (d.timeend = 0 OR d.timeend > :now2)";
2821         $params['now1'] = $now;
2822         $params['now2'] = $now;
2823     } else {
2824         $timedsql = "";
2825     }
2827     $sql = "SELECT d.id, COUNT(p.id) AS unread
2828               FROM {forum_discussions} d
2829                    JOIN {forum_posts} p     ON p.discussion = d.id
2830                    LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = $USER->id)
2831              WHERE d.forum = {$cm->instance}
2832                    AND p.modified >= :cutoffdate AND r.id is NULL
2833                    $groupselect
2834                    $timedsql
2835           GROUP BY d.id";
2836     $params['cutoffdate'] = $cutoffdate;
2838     if ($unreads = $DB->get_records_sql($sql, $params)) {
2839         foreach ($unreads as $unread) {
2840             $unreads[$unread->id] = $unread->unread;
2841         }
2842         return $unreads;
2843     } else {
2844         return array();
2845     }
2848 /**
2849  * @global object
2850  * @global object
2851  * @global object
2852  * @uses CONEXT_MODULE
2853  * @uses VISIBLEGROUPS
2854  * @param object $cm
2855  * @return array
2856  */
2857 function forum_get_discussions_count($cm) {
2858     global $CFG, $DB, $USER;
2860     $now = round(time(), -2);
2861     $params = array($cm->instance);
2862     $groupmode    = groups_get_activity_groupmode($cm);
2863     $currentgroup = groups_get_activity_group($cm);
2865     if ($groupmode) {
2866         $modcontext = context_module::instance($cm->id);
2868         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2869             if ($currentgroup) {
2870                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2871                 $params[] = $currentgroup;
2872             } else {
2873                 $groupselect = "";
2874             }
2876         } else {
2877             //seprate groups without access all
2878             if ($currentgroup) {
2879                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2880                 $params[] = $currentgroup;
2881             } else {
2882                 $groupselect = "AND d.groupid = -1";
2883             }
2884         }
2885     } else {
2886         $groupselect = "";
2887     }
2889     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2891     $timelimit = "";
2893     if (!empty($CFG->forum_enabletimedposts)) {
2895         $modcontext = context_module::instance($cm->id);
2897         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2898             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2899             $params[] = $now;
2900             $params[] = $now;
2901             if (isloggedin()) {
2902                 $timelimit .= " OR d.userid = ?";
2903                 $params[] = $USER->id;
2904             }
2905             $timelimit .= ")";
2906         }
2907     }
2909     $sql = "SELECT COUNT(d.id)
2910               FROM {forum_discussions} d
2911                    JOIN {forum_posts} p ON p.discussion = d.id
2912              WHERE d.forum = ? AND p.parent = 0
2913                    $groupselect $timelimit";
2915     return $DB->get_field_sql($sql, $params);
2919 // OTHER FUNCTIONS ///////////////////////////////////////////////////////////
2922 /**
2923  * @global object
2924  * @global object
2925  * @param int $courseid
2926  * @param string $type
2927  */
2928 function forum_get_course_forum($courseid, $type) {
2929 // How to set up special 1-per-course forums
2930     global $CFG, $DB, $OUTPUT, $USER;
2932     if ($forums = $DB->get_records_select("forum", "course = ? AND type = ?", array($courseid, $type), "id ASC")) {
2933         // There should always only be ONE, but with the right combination of
2934         // errors there might be more.  In this case, just return the oldest one (lowest ID).
2935         foreach ($forums as $forum) {
2936             return $forum;   // ie the first one
2937         }
2938     }
2940     // Doesn't exist, so create one now.
2941     $forum = new stdClass();
2942     $forum->course = $courseid;
2943     $forum->type = "$type";
2944     if (!empty($USER->htmleditor)) {
2945         $forum->introformat = $USER->htmleditor;
2946     }
2947     switch ($forum->type) {
2948         case "news":
2949             $forum->name  = get_string("namenews", "forum");
2950             $forum->intro = get_string("intronews", "forum");
2951             $forum->forcesubscribe = FORUM_FORCESUBSCRIBE;
2952             $forum->assessed = 0;
2953             if ($courseid == SITEID) {
2954                 $forum->name  = get_string("sitenews");
2955                 $forum->forcesubscribe = 0;
2956             }
2957             break;
2958         case "social":
2959             $forum->name  = get_string("namesocial", "forum");
2960             $forum->intro = get_string("introsocial", "forum");
2961             $forum->assessed = 0;
2962             $forum->forcesubscribe = 0;
2963             break;
2964         case "blog":
2965             $forum->name = get_string('blogforum', 'forum');
2966             $forum->intro = get_string('introblog', 'forum');
2967             $forum->assessed = 0;
2968             $forum->forcesubscribe = 0;
2969             break;
2970         default:
2971             echo $OUTPUT->notification("That forum type doesn't exist!");
2972             return false;
2973             break;
2974     }
2976     $forum->timemodified = time();
2977     $forum->id = $DB->insert_record("forum", $forum);
2979     if (! $module = $DB->get_record("modules", array("name" => "forum"))) {
2980         echo $OUTPUT->notification("Could not find forum module!!");
2981         return false;
2982     }
2983     $mod = new stdClass();
2984     $mod->course = $courseid;
2985     $mod->module = $module->id;
2986     $mod->instance = $forum->id;
2987     $mod->section = 0;
2988     include_once("$CFG->dirroot/course/lib.php");
2989     if (! $mod->coursemodule = add_course_module($mod) ) {
2990         echo $OUTPUT->notification("Could not add a new course module to the course '" . $courseid . "'");
2991         return false;
2992     }
2993     $sectionid = course_add_cm_to_section($courseid, $mod->coursemodule, 0);
2994     return $DB->get_record("forum", array("id" => "$forum->id"));
2997 /**
2998  * Print a forum post
2999  *
3000  * @global object
3001  * @global object
3002  * @uses FORUM_MODE_THREADED
3003  * @uses PORTFOLIO_FORMAT_PLAINHTML
3004  * @uses PORTFOLIO_FORMAT_FILE
3005  * @uses PORTFOLIO_FORMAT_RICHHTML
3006  * @uses PORTFOLIO_ADD_TEXT_LINK
3007  * @uses CONTEXT_MODULE
3008  * @param object $post The post to print.
3009  * @param object $discussion
3010  * @param object $forum
3011  * @param object $cm
3012  * @param object $course
3013  * @param boolean $ownpost Whether this post belongs to the current user.
3014  * @param boolean $reply Whether to print a 'reply' link at the bottom of the message.
3015  * @param boolean $link Just print a shortened version of the post as a link to the full post.
3016  * @param string $footer Extra stuff to print after the message.
3017  * @param string $highlight Space-separated list of terms to highlight.
3018  * @param int $post_read true, false or -99. If we already know whether this user
3019  *          has read this post, pass that in, otherwise, pass in -99, and this
3020  *          function will work it out.
3021  * @param boolean $dummyifcantsee When forum_user_can_see_post says that
3022  *          the current user can't see this post, if this argument is true
3023  *          (the default) then print a dummy 'you can't see this post' post.
3024  *          If false, don't output anything at all.
3025  * @param bool|null $istracked
3026  * @return void
3027  */
3028 function forum_print_post($post, $discussion, $forum, &$cm, $course, $ownpost=false, $reply=false, $link=false,
3029                           $footer="", $highlight="", $postisread=null, $dummyifcantsee=true, $istracked=null, $return=false) {
3030     global $USER, $CFG, $OUTPUT;
3032     require_once($CFG->libdir . '/filelib.php');
3034     // String cache
3035     static $str;
3037     $modcontext = context_module::instance($cm->id);
3039     $post->course = $course->id;
3040     $post->forum  = $forum->id;
3041     $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
3042     if (!empty($CFG->enableplagiarism)) {
3043         require_once($CFG->libdir.'/plagiarismlib.php');
3044         $post->message .= plagiarism_get_links(array('userid' => $post->userid,
3045             'content' => $post->message,
3046             'cmid' => $cm->id,
3047             'course' => $post->course,
3048             'forum' => $post->forum));
3049     }
3051     // caching
3052     if (!isset($cm->cache)) {
3053         $cm->cache = new stdClass;
3054     }
3056     if (!isset($cm->cache->caps)) {
3057         $cm->cache->caps = array();
3058         $cm->cache->caps['mod/forum:viewdiscussion']   = has_capability('mod/forum:viewdiscussion', $modcontext);
3059         $cm->cache->caps['moodle/site:viewfullnames']  = has_capability('moodle/site:viewfullnames', $modcontext);
3060         $cm->cache->caps['mod/forum:editanypost']      = has_capability('mod/forum:editanypost', $modcontext);
3061         $cm->cache->caps['mod/forum:splitdiscussions'] = has_capability('mod/forum:splitdiscussions', $modcontext);
3062         $cm->cache->caps['mod/forum:deleteownpost']    = has_capability('mod/forum:deleteownpost', $modcontext);
3063         $cm->cache->caps['mod/forum:deleteanypost']    = has_capability('mod/forum:deleteanypost', $modcontext);
3064         $cm->cache->caps['mod/forum:viewanyrating']    = has_capability('mod/forum:viewanyrating', $modcontext);
3065         $cm->cache->caps['mod/forum:exportpost']       = has_capability('mod/forum:exportpost', $modcontext);
3066         $cm->cache->caps['mod/forum:exportownpost']    = has_capability('mod/forum:exportownpost', $modcontext);
3067     }
3069     if (!isset($cm->uservisible)) {
3070         $cm->uservisible = \core_availability\info_module::is_user_visible($cm, 0, false);
3071     }
3073     if ($istracked && is_null($postisread)) {
3074         $postisread = forum_tp_is_post_read($USER->id, $post);
3075     }
3077     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
3078         $output = '';
3079         if (!$dummyifcantsee) {
3080             if ($return) {
3081                 return $output;
3082             }
3083             echo $output;
3084             return;
3085         }
3086         $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3087         $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix',
3088                                                        'role' => 'region',
3089                                                        'aria-label' => get_string('hiddenforumpost', 'forum')));
3090         $output .= html_writer::start_tag('div', array('class'=>'row header'));
3091         $output .= html_writer::tag('div', '', array('class'=>'left picture')); // Picture
3092         if ($post->parent) {
3093             $output .= html_writer::start_tag('div', array('class'=>'topic'));
3094         } else {
3095             $output .= html_writer::start_tag('div', array('class'=>'topic starter'));
3096         }
3097         $output .= html_writer::tag('div', get_string('forumsubjecthidden','forum'), array('class' => 'subject',
3098                                                                                            'role' => 'header')); // Subject.
3099         $output .= html_writer::tag('div', get_string('forumauthorhidden', 'forum'), array('class' => 'author',
3100                                                                                            'role' => 'header')); // Author.
3101         $output .= html_writer::end_tag('div');
3102         $output .= html_writer::end_tag('div'); // row
3103         $output .= html_writer::start_tag('div', array('class'=>'row'));
3104         $output .= html_writer::tag('div', '&nbsp;', array('class'=>'left side')); // Groups
3105         $output .= html_writer::tag('div', get_string('forumbodyhidden','forum'), array('class'=>'content')); // Content
3106         $output .= html_writer::end_tag('div'); // row
3107         $output .= html_writer::end_tag('div'); // forumpost
3109         if ($return) {
3110             return $output;
3111         }
3112         echo $output;
3113         return;
3114     }
3116     if (empty($str)) {
3117         $str = new stdClass;
3118         $str->edit         = get_string('edit', 'forum');
3119         $str->delete       = get_string('delete', 'forum');
3120         $str->reply        = get_string('reply', 'forum');
3121         $str->parent       = get_string('parent', 'forum');
3122         $str->pruneheading = get_string('pruneheading', 'forum');
3123         $str->prune        = get_string('prune', 'forum');
3124         $str->displaymode     = get_user_preferences('forum_displaymode', $CFG->forum_displaymode);
3125         $str->markread     = get_string('markread', 'forum');
3126         $str->markunread   = get_string('markunread', 'forum');
3127     }
3129     $discussionlink = new moodle_url('/mod/forum/discuss.php', array('d'=>$post->discussion));
3131     // Build an object that represents the posting user
3132     $postuser = new stdClass;
3133     $postuserfields = explode(',', user_picture::fields());
3134     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
3135     $postuser->id = $post->userid;
3136     $postuser->fullname    = fullname($postuser, $cm->cache->caps['moodle/site:viewfullnames']);
3137     $postuser->profilelink = new moodle_url('/user/view.php', array('id'=>$post->userid, 'course'=>$course->id));
3139     // Prepare the groups the posting user belongs to
3140     if (isset($cm->cache->usersgroups)) {
3141         $groups = array();
3142         if (isset($cm->cache->usersgroups[$post->userid])) {
3143             foreach ($cm->cache->usersgroups[$post->userid] as $gid) {
3144                 $groups[$gid] = $cm->cache->groups[$gid];
3145             }
3146         }
3147     } else {
3148         $groups = groups_get_all_groups($course->id, $post->userid, $cm->groupingid);
3149     }
3151     // Prepare the attachements for the post, files then images
3152     list($attachments, $attachedimages) = forum_print_attachments($post, $cm, 'separateimages');
3154     // Determine if we need to shorten this post
3155     $shortenpost = ($link && (strlen(strip_tags($post->message)) > $CFG->forum_longpost));
3158     // Prepare an array of commands
3159     $commands = array();
3161     // SPECIAL CASE: The front page can display a news item post to non-logged in users.
3162     // Don't display the mark read / unread controls in this case.
3163     if ($istracked && $CFG->forum_usermarksread && isloggedin()) {
3164         $url = new moodle_url($discussionlink, array('postid'=>$post->id, 'mark'=>'unread'));
3165         $text = $str->markunread;
3166         if (!$postisread) {
3167             $url->param('mark', 'read');
3168             $text = $str->markread;
3169         }
3170         if ($str->displaymode == FORUM_MODE_THREADED) {
3171             $url->param('parent', $post->parent);
3172         } else {
3173             $url->set_anchor('p'.$post->id);
3174         }
3175         $commands[] = array('url'=>$url, 'text'=>$text);
3176     }
3178     // Zoom in to the parent specifically
3179     if ($post->parent) {
3180         $url = new moodle_url($discussionlink);
3181         if ($str->displaymode == FORUM_MODE_THREADED) {
3182             $url->param('parent', $post->parent);
3183         } else {
3184             $url->set_anchor('p'.$post->parent);
3185         }
3186         $commands[] = array('url'=>$url, 'text'=>$str->parent);
3187     }
3189     // Hack for allow to edit news posts those are not displayed yet until they are displayed
3190     $age = time() - $post->created;
3191     if (!$post->parent && $forum->type == 'news' && $discussion->timestart > time()) {
3192         $age = 0;
3193     }
3195     if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3196         if (has_capability('moodle/course:manageactivities', $modcontext)) {
3197             // The first post in single simple is the forum description.
3198             $commands[] = array('url'=>new moodle_url('/course/modedit.php', array('update'=>$cm->id, 'sesskey'=>sesskey(), 'return'=>1)), 'text'=>$str->edit);
3199         }
3200     } else if (($ownpost && $age < $CFG->maxeditingtime) || $cm->cache->caps['mod/forum:editanypost']) {
3201         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('edit'=>$post->id)), 'text'=>$str->edit);
3202     }
3204     if ($cm->cache->caps['mod/forum:splitdiscussions'] && $post->parent && $forum->type != 'single') {
3205         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('prune'=>$post->id)), 'text'=>$str->prune, 'title'=>$str->pruneheading);
3206     }
3208     if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3209         // Do not allow deleting of first post in single simple type.
3210     } else if (($ownpost && $age < $CFG->maxeditingtime && $cm->cache->caps['mod/forum:deleteownpost']) || $cm->cache->caps['mod/forum:deleteanypost']) {
3211         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('delete'=>$post->id)), 'text'=>$str->delete);
3212     }
3214     if ($reply) {
3215         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php#mformforum', array('reply'=>$post->id)), 'text'=>$str->reply);
3216     }
3218     if ($CFG->enableportfolios && ($cm->cache->caps['mod/forum:exportpost'] || ($ownpost && $cm->cache->caps['mod/forum:exportownpost']))) {
3219         $p = array('postid' => $post->id);
3220         require_once($CFG->libdir.'/portfoliolib.php');
3221         $button = new portfolio_add_button();
3222         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id), 'mod_forum');
3223         if (empty($attachments)) {
3224             $button->set_formats(PORTFOLIO_FORMAT_PLAINHTML);
3225         } else {
3226             $button->set_formats(PORTFOLIO_FORMAT_RICHHTML);
3227         }
3229         $porfoliohtml = $button->to_html(PORTFOLIO_ADD_TEXT_LINK);
3230         if (!empty($porfoliohtml)) {
3231             $commands[] = $porfoliohtml;
3232         }
3233     }
3234     // Finished building commands
3237     // Begin output
3239     $output  = '';
3241     if ($istracked) {
3242         if ($postisread) {
3243             $forumpostclass = ' read';
3244         } else {
3245             $forumpostclass = ' unread';
3246             $output .= html_writer::tag('a', '', array('name'=>'unread'));
3247         }
3248     } else {
3249         // ignore trackign status if not tracked or tracked param missing
3250         $forumpostclass = '';
3251     }
3253     $topicclass = '';
3254     if (empty($post->parent)) {
3255         $topicclass = ' firstpost starter';
3256     }
3258     if (!empty($post->lastpost)) {
3259         $forumpostclass .= ' lastpost';
3260     }
3262     $postbyuser = new stdClass;
3263     $postbyuser->post = $post->subject;
3264     $postbyuser->user = $postuser->fullname;
3265     $discussionbyuser = get_string('postbyuser', 'forum', $postbyuser);
3266     $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3267     $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix'.$forumpostclass.$topicclass,
3268                                                    'role' => 'region',
3269                                                    'aria-label' => $discussionbyuser));
3270     $output .= html_writer::start_tag('div', array('class'=>'row header clearfix'));
3271     $output .= html_writer::start_tag('div', array('class'=>'left picture'));
3272     $output .= $OUTPUT->user_picture($postuser, array('courseid'=>$course->id));
3273     $output .= html_writer::end_tag('div');
3276     $output .= html_writer::start_tag('div', array('class'=>'topic'.$topicclass));
3278     $postsubject = $post->subject;
3279     if (empty($post->subjectnoformat)) {
3280         $postsubject = format_string($postsubject);
3281     }
3282     $output .= html_writer::tag('div', $postsubject, array('class'=>'subject',
3283                                                            'role' => 'heading',
3284                                                            'aria-level' => '2'));
3286     $by = new stdClass();
3287     $by->name = html_writer::link($postuser->profilelink, $postuser->fullname);
3288     $by->date = userdate($post->modified);
3289     $output .= html_writer::tag('div', get_string('bynameondate', 'forum', $by), array('class'=>'author',
3290                                                                                        'role' => 'heading',
3291                                                                                        'aria-level' => '2'));
3293     $output .= html_writer::end_tag('div'); //topic
3294     $output .= html_writer::end_tag('div'); //row
3296     $output .= html_writer::start_tag('div', array('class'=>'row maincontent clearfix'));
3297     $output .= html_writer::start_tag('div', array('class'=>'left'));
3299     $groupoutput = '';
3300     if ($groups) {
3301         $groupoutput = print_group_picture($groups, $course->id, false, true, true);
3302     }
3303     if (empty($groupoutput)) {
3304         $groupoutput = '&nbsp;';
3305     }
3306     $output .= html_writer::tag('div', $groupoutput, array('class'=>'grouppictures'));
3308     $output .= html_writer::end_tag('div'); //left side
3309     $output .= html_writer::start_tag('div', array('class'=>'no-overflow'));
3310     $output .= html_writer::start_tag('div', array('class'=>'content'));
3312     $options = new stdClass;
3313     $options->para    = false;
3314     $options->trusted = $post->messagetrust;
3315     $options->context = $modcontext;
3316     if ($shortenpost) {
3317         // Prepare shortened version by filtering the text then shortening it.
3318         $postclass    = 'shortenedpost';
3319         $postcontent  = format_text($post->message, $post->messageformat, $options);
3320         $postcontent  = shorten_text($postcontent, $CFG->forum_shortpost);
3321         $postcontent .= html_writer::link($discussionlink, get_string('readtherest', 'forum'));
3322         $postcontent .= html_writer::tag('div', '('.get_string('numwords', 'moodle', count_words($post->message)).')',
3323             array('class'=>'post-word-count'));
3324     } else {
3325         // Prepare whole post
3326         $postclass    = 'fullpost';
3327         $postcontent  = format_text($post->message, $post->messageformat, $options, $course->id);
3328         if (!empty($highlight)) {
3329             $postcontent = highlight($highlight, $postcontent);
3330         }
3331         if (!empty($forum->displaywordcount)) {
3332             $postcontent .= html_writer::tag('div', get_string('numwords', 'moodle', count_words($post->message)),
3333                 array('class'=>'post-word-count'));
3334         }
3335         $postcontent .= html_writer::tag('div', $attachedimages, array('class'=>'attachedimages'));
3336     }
3338     // Output the post content
3339     $output .= html_writer::tag('div', $postcontent, array('class'=>'posting '.$postclass));
3340     $output .= html_writer::end_tag('div'); // Content
3341     $output .= html_writer::end_tag('div'); // Content mask
3342     $output .= html_writer::end_tag('div'); // Row
3344     $output .= html_writer::start_tag('div', array('class'=>'row side'));
3345     $output .= html_writer::tag('div','&nbsp;', array('class'=>'left'));
3346     $output .= html_writer::start_tag('div', array('class'=>'options clearfix'));
3348     if (!empty($attachments)) {
3349         $output .= html_writer::tag('div', $attachments, array('class' => 'attachments'));
3350     }
3352     // Output ratings
3353     if (!empty($post->rating)) {
3354         $output .= html_writer::tag('div', $OUTPUT->render($post->rating), array('class'=>'forum-post-rating'));
3355     }
3357     // Output the commands
3358     $commandhtml = array();
3359     foreach ($commands as $command) {
3360         if (is_array($command)) {
3361             $commandhtml[] = html_writer::link($command['url'], $command['text']);
3362         } else {
3363             $commandhtml[] = $command;
3364         }
3365     }
3366     $output .= html_writer::tag('div', implode(' | ', $commandhtml), array('class'=>'commands'));
3368     // Output link to post if required
3369     if ($link && forum_user_can_post($forum, $discussion, $USER, $cm, $course, $modcontext)) {
3370         if ($post->replies == 1) {
3371             $replystring = get_string('repliesone', 'forum', $post->replies);
3372         } else {
3373             $replystring = get_string('repliesmany', 'forum', $post->replies);
3374         }
3375         if (!empty($discussion->unread) && $discussion->unread !== '-') {
3376             $replystring .= ' <span class="sep">/</span> <span class="unread">';
3377             if ($discussion->unread == 1) {
3378                 $replystring .= get_string('unreadpostsone', 'forum');
3379             } else {
3380                 $replystring .= get_string('unreadpostsnumber', 'forum', $discussion->unread);
3381             }
3382             $replystring .= '</span>';
3383         }
3385         $output .= html_writer::start_tag('div', array('class'=>'link'));
3386         $output .= html_writer::link($discussionlink, get_string('discussthistopic', 'forum'));
3387         $output .= '&nbsp;('.$replystring.')';
3388         $output .= html_writer::end_tag('div'); // link
3389     }
3391     // Output footer if required
3392     if ($footer) {
3393         $output .= html_writer::tag('div', $footer, array('class'=>'footer'));
3394     }
3396     // Close remaining open divs
3397     $output .= html_writer::end_tag('div'); // content
3398     $output .= html_writer::end_tag('div'); // row
3399     $output .= html_writer::end_tag('div'); // forumpost
3401     // Mark the forum post as read if required
3402     if ($istracked && !$CFG->forum_usermarksread && !$postisread) {
3403         forum_tp_mark_post_read($USER->id, $post, $forum->id);
3404     }
3406     if ($return) {
3407         return $output;
3408     }
3409     echo $output;
3410     return;
3413 /**
3414  * Return rating related permissions
3415  *
3416  * @param string $options the context id
3417  * @return array an associative array of the user's rating permissions
3418  */
3419 function forum_rating_permissions($contextid, $component, $ratingarea) {
3420     $context = context::instance_by_id($contextid, MUST_EXIST);
3421     if ($component != 'mod_forum' || $ratingarea != 'post') {
3422         // We don't know about this component/ratingarea so just return null to get the
3423         // default restrictive permissions.
3424         return null;
3425     }
3426     return array(
3427         'view'    => has_capability('mod/forum:viewrating', $context),
3428         'viewany' => has_capability('mod/forum:viewanyrating', $context),
3429         'viewall' => has_capability('mod/forum:viewallratings', $context),
3430         'rate'    => has_capability('mod/forum:rate', $context)
3431     );
3434 /**
3435  * Validates a submitted rating
3436  * @param array $params submitted data
3437  *            context => object the context in which the rated items exists [required]
3438  *            component => The component for this module - should always be mod_forum [required]
3439  *            ratingarea => object the context in which the rated items exists [required]
3440  *            itemid => int the ID of the object being rated [required]
3441  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
3442  *        &n