d993c41fa7cf748863a61b0061291213776863d6
[moodle.git] / mod / forum / lib.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * @package   mod_forum
19  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
20  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
21  */
23 defined('MOODLE_INTERNAL') || die();
25 /** Include required files */
26 require_once(__DIR__ . '/deprecatedlib.php');
27 require_once($CFG->libdir.'/filelib.php');
28 require_once($CFG->libdir.'/eventslib.php');
30 /// CONSTANTS ///////////////////////////////////////////////////////////
32 define('FORUM_MODE_FLATOLDEST', 1);
33 define('FORUM_MODE_FLATNEWEST', -1);
34 define('FORUM_MODE_THREADED', 2);
35 define('FORUM_MODE_NESTED', 3);
37 define('FORUM_CHOOSESUBSCRIBE', 0);
38 define('FORUM_FORCESUBSCRIBE', 1);
39 define('FORUM_INITIALSUBSCRIBE', 2);
40 define('FORUM_DISALLOWSUBSCRIBE',3);
42 /**
43  * FORUM_TRACKING_OFF - Tracking is not available for this forum.
44  */
45 define('FORUM_TRACKING_OFF', 0);
47 /**
48  * FORUM_TRACKING_OPTIONAL - Tracking is based on user preference.
49  */
50 define('FORUM_TRACKING_OPTIONAL', 1);
52 /**
53  * FORUM_TRACKING_FORCED - Tracking is on, regardless of user setting.
54  * Treated as FORUM_TRACKING_OPTIONAL if $CFG->forum_allowforcedreadtracking is off.
55  */
56 define('FORUM_TRACKING_FORCED', 2);
58 define('FORUM_MAILED_PENDING', 0);
59 define('FORUM_MAILED_SUCCESS', 1);
60 define('FORUM_MAILED_ERROR', 2);
62 if (!defined('FORUM_CRON_USER_CACHE')) {
63     /** Defines how many full user records are cached in forum cron. */
64     define('FORUM_CRON_USER_CACHE', 5000);
65 }
67 /**
68  * FORUM_POSTS_ALL_USER_GROUPS - All the posts in groups where the user is enrolled.
69  */
70 define('FORUM_POSTS_ALL_USER_GROUPS', -2);
72 define('FORUM_DISCUSSION_PINNED', 1);
73 define('FORUM_DISCUSSION_UNPINNED', 0);
75 /// STANDARD FUNCTIONS ///////////////////////////////////////////////////////////
77 /**
78  * Given an object containing all the necessary data,
79  * (defined by the form in mod_form.php) this function
80  * will create a new instance and return the id number
81  * of the new instance.
82  *
83  * @param stdClass $forum add forum instance
84  * @param mod_forum_mod_form $mform
85  * @return int intance id
86  */
87 function forum_add_instance($forum, $mform = null) {
88     global $CFG, $DB;
90     $forum->timemodified = time();
92     if (empty($forum->assessed)) {
93         $forum->assessed = 0;
94     }
96     if (empty($forum->ratingtime) or empty($forum->assessed)) {
97         $forum->assesstimestart  = 0;
98         $forum->assesstimefinish = 0;
99     }
101     $forum->id = $DB->insert_record('forum', $forum);
102     $modcontext = context_module::instance($forum->coursemodule);
104     if ($forum->type == 'single') {  // Create related discussion.
105         $discussion = new stdClass();
106         $discussion->course        = $forum->course;
107         $discussion->forum         = $forum->id;
108         $discussion->name          = $forum->name;
109         $discussion->assessed      = $forum->assessed;
110         $discussion->message       = $forum->intro;
111         $discussion->messageformat = $forum->introformat;
112         $discussion->messagetrust  = trusttext_trusted(context_course::instance($forum->course));
113         $discussion->mailnow       = false;
114         $discussion->groupid       = -1;
116         $message = '';
118         $discussion->id = forum_add_discussion($discussion, null, $message);
120         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
121             // Ugly hack - we need to copy the files somehow.
122             $discussion = $DB->get_record('forum_discussions', array('id'=>$discussion->id), '*', MUST_EXIST);
123             $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
125             $options = array('subdirs'=>true); // Use the same options as intro field!
126             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
127             $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
128         }
129     }
131     forum_grade_item_update($forum);
133     return $forum->id;
136 /**
137  * Handle changes following the creation of a forum instance.
138  * This function is typically called by the course_module_created observer.
139  *
140  * @param object $context the forum context
141  * @param stdClass $forum The forum object
142  * @return void
143  */
144 function forum_instance_created($context, $forum) {
145     if ($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) {
146         $users = \mod_forum\subscriptions::get_potential_subscribers($context, 0, 'u.id, u.email');
147         foreach ($users as $user) {
148             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $context);
149         }
150     }
153 /**
154  * Given an object containing all the necessary data,
155  * (defined by the form in mod_form.php) this function
156  * will update an existing instance with new data.
157  *
158  * @global object
159  * @param object $forum forum instance (with magic quotes)
160  * @return bool success
161  */
162 function forum_update_instance($forum, $mform) {
163     global $DB, $OUTPUT, $USER;
165     $forum->timemodified = time();
166     $forum->id           = $forum->instance;
168     if (empty($forum->assessed)) {
169         $forum->assessed = 0;
170     }
172     if (empty($forum->ratingtime) or empty($forum->assessed)) {
173         $forum->assesstimestart  = 0;
174         $forum->assesstimefinish = 0;
175     }
177     $oldforum = $DB->get_record('forum', array('id'=>$forum->id));
179     // MDL-3942 - if the aggregation type or scale (i.e. max grade) changes then recalculate the grades for the entire forum
180     // if  scale changes - do we need to recheck the ratings, if ratings higher than scale how do we want to respond?
181     // for count and sum aggregation types the grade we check to make sure they do not exceed the scale (i.e. max score) when calculating the grade
182     if (($oldforum->assessed<>$forum->assessed) or ($oldforum->scale<>$forum->scale)) {
183         forum_update_grades($forum); // recalculate grades for the forum
184     }
186     if ($forum->type == 'single') {  // Update related discussion and post.
187         $discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id), 'timemodified ASC');
188         if (!empty($discussions)) {
189             if (count($discussions) > 1) {
190                 echo $OUTPUT->notification(get_string('warnformorepost', 'forum'));
191             }
192             $discussion = array_pop($discussions);
193         } else {
194             // try to recover by creating initial discussion - MDL-16262
195             $discussion = new stdClass();
196             $discussion->course          = $forum->course;
197             $discussion->forum           = $forum->id;
198             $discussion->name            = $forum->name;
199             $discussion->assessed        = $forum->assessed;
200             $discussion->message         = $forum->intro;
201             $discussion->messageformat   = $forum->introformat;
202             $discussion->messagetrust    = true;
203             $discussion->mailnow         = false;
204             $discussion->groupid         = -1;
206             $message = '';
208             forum_add_discussion($discussion, null, $message);
210             if (! $discussion = $DB->get_record('forum_discussions', array('forum'=>$forum->id))) {
211                 print_error('cannotadd', 'forum');
212             }
213         }
214         if (! $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost))) {
215             print_error('cannotfindfirstpost', 'forum');
216         }
218         $cm         = get_coursemodule_from_instance('forum', $forum->id);
219         $modcontext = context_module::instance($cm->id, MUST_EXIST);
221         $post = $DB->get_record('forum_posts', array('id'=>$discussion->firstpost), '*', MUST_EXIST);
222         $post->subject       = $forum->name;
223         $post->message       = $forum->intro;
224         $post->messageformat = $forum->introformat;
225         $post->messagetrust  = trusttext_trusted($modcontext);
226         $post->modified      = $forum->timemodified;
227         $post->userid        = $USER->id;    // MDL-18599, so that current teacher can take ownership of activities.
229         if ($mform and $draftid = file_get_submitted_draft_itemid('introeditor')) {
230             // Ugly hack - we need to copy the files somehow.
231             $options = array('subdirs'=>true); // Use the same options as intro field!
232             $post->message = file_save_draft_area_files($draftid, $modcontext->id, 'mod_forum', 'post', $post->id, $options, $post->message);
233         }
235         $DB->update_record('forum_posts', $post);
236         $discussion->name = $forum->name;
237         $DB->update_record('forum_discussions', $discussion);
238     }
240     $DB->update_record('forum', $forum);
242     $modcontext = context_module::instance($forum->coursemodule);
243     if (($forum->forcesubscribe == FORUM_INITIALSUBSCRIBE) && ($oldforum->forcesubscribe <> $forum->forcesubscribe)) {
244         $users = \mod_forum\subscriptions::get_potential_subscribers($modcontext, 0, 'u.id, u.email', '');
245         foreach ($users as $user) {
246             \mod_forum\subscriptions::subscribe_user($user->id, $forum, $modcontext);
247         }
248     }
250     forum_grade_item_update($forum);
252     return true;
256 /**
257  * Given an ID of an instance of this module,
258  * this function will permanently delete the instance
259  * and any data that depends on it.
260  *
261  * @global object
262  * @param int $id forum instance id
263  * @return bool success
264  */
265 function forum_delete_instance($id) {
266     global $DB;
268     if (!$forum = $DB->get_record('forum', array('id'=>$id))) {
269         return false;
270     }
271     if (!$cm = get_coursemodule_from_instance('forum', $forum->id)) {
272         return false;
273     }
274     if (!$course = $DB->get_record('course', array('id'=>$cm->course))) {
275         return false;
276     }
278     $context = context_module::instance($cm->id);
280     // now get rid of all files
281     $fs = get_file_storage();
282     $fs->delete_area_files($context->id);
284     $result = true;
286     // Delete digest and subscription preferences.
287     $DB->delete_records('forum_digests', array('forum' => $forum->id));
288     $DB->delete_records('forum_subscriptions', array('forum'=>$forum->id));
289     $DB->delete_records('forum_discussion_subs', array('forum' => $forum->id));
291     if ($discussions = $DB->get_records('forum_discussions', array('forum'=>$forum->id))) {
292         foreach ($discussions as $discussion) {
293             if (!forum_delete_discussion($discussion, true, $course, $cm, $forum)) {
294                 $result = false;
295             }
296         }
297     }
299     forum_tp_delete_read_records(-1, -1, -1, $forum->id);
301     if (!$DB->delete_records('forum', array('id'=>$forum->id))) {
302         $result = false;
303     }
305     forum_grade_item_delete($forum);
307     return $result;
311 /**
312  * Indicates API features that the forum supports.
313  *
314  * @uses FEATURE_GROUPS
315  * @uses FEATURE_GROUPINGS
316  * @uses FEATURE_MOD_INTRO
317  * @uses FEATURE_COMPLETION_TRACKS_VIEWS
318  * @uses FEATURE_COMPLETION_HAS_RULES
319  * @uses FEATURE_GRADE_HAS_GRADE
320  * @uses FEATURE_GRADE_OUTCOMES
321  * @param string $feature
322  * @return mixed True if yes (some features may use other values)
323  */
324 function forum_supports($feature) {
325     switch($feature) {
326         case FEATURE_GROUPS:                  return true;
327         case FEATURE_GROUPINGS:               return true;
328         case FEATURE_MOD_INTRO:               return true;
329         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
330         case FEATURE_COMPLETION_HAS_RULES:    return true;
331         case FEATURE_GRADE_HAS_GRADE:         return true;
332         case FEATURE_GRADE_OUTCOMES:          return true;
333         case FEATURE_RATE:                    return true;
334         case FEATURE_BACKUP_MOODLE2:          return true;
335         case FEATURE_SHOW_DESCRIPTION:        return true;
336         case FEATURE_PLAGIARISM:              return true;
338         default: return null;
339     }
343 /**
344  * Obtains the automatic completion state for this forum based on any conditions
345  * in forum settings.
346  *
347  * @global object
348  * @global object
349  * @param object $course Course
350  * @param object $cm Course-module
351  * @param int $userid User ID
352  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
353  * @return bool True if completed, false if not. (If no conditions, then return
354  *   value depends on comparison type)
355  */
356 function forum_get_completion_state($course,$cm,$userid,$type) {
357     global $CFG,$DB;
359     // Get forum details
360     if (!($forum=$DB->get_record('forum',array('id'=>$cm->instance)))) {
361         throw new Exception("Can't find forum {$cm->instance}");
362     }
364     $result=$type; // Default return value
366     $postcountparams=array('userid'=>$userid,'forumid'=>$forum->id);
367     $postcountsql="
368 SELECT
369     COUNT(1)
370 FROM
371     {forum_posts} fp
372     INNER JOIN {forum_discussions} fd ON fp.discussion=fd.id
373 WHERE
374     fp.userid=:userid AND fd.forum=:forumid";
376     if ($forum->completiondiscussions) {
377         $value = $forum->completiondiscussions <=
378                  $DB->count_records('forum_discussions',array('forum'=>$forum->id,'userid'=>$userid));
379         if ($type == COMPLETION_AND) {
380             $result = $result && $value;
381         } else {
382             $result = $result || $value;
383         }
384     }
385     if ($forum->completionreplies) {
386         $value = $forum->completionreplies <=
387                  $DB->get_field_sql( $postcountsql.' AND fp.parent<>0',$postcountparams);
388         if ($type==COMPLETION_AND) {
389             $result = $result && $value;
390         } else {
391             $result = $result || $value;
392         }
393     }
394     if ($forum->completionposts) {
395         $value = $forum->completionposts <= $DB->get_field_sql($postcountsql,$postcountparams);
396         if ($type == COMPLETION_AND) {
397             $result = $result && $value;
398         } else {
399             $result = $result || $value;
400         }
401     }
403     return $result;
406 /**
407  * Create a message-id string to use in the custom headers of forum notification emails
408  *
409  * message-id is used by email clients to identify emails and to nest conversations
410  *
411  * @param int $postid The ID of the forum post we are notifying the user about
412  * @param int $usertoid The ID of the user being notified
413  * @param string $hostname The server's hostname
414  * @return string A unique message-id
415  */
416 function forum_get_email_message_id($postid, $usertoid, $hostname) {
417     return '<'.hash('sha256',$postid.'to'.$usertoid).'@'.$hostname.'>';
420 /**
421  * Removes properties from user record that are not necessary
422  * for sending post notifications.
423  * @param stdClass $user
424  * @return void, $user parameter is modified
425  */
426 function forum_cron_minimise_user_record(stdClass $user) {
428     // We store large amount of users in one huge array,
429     // make sure we do not store info there we do not actually need
430     // in mail generation code or messaging.
432     unset($user->institution);
433     unset($user->department);
434     unset($user->address);
435     unset($user->city);
436     unset($user->url);
437     unset($user->currentlogin);
438     unset($user->description);
439     unset($user->descriptionformat);
442 /**
443  * Function to be run periodically according to the scheduled task.
444  *
445  * Finds all posts that have yet to be mailed out, and mails them
446  * out to all subscribers as well as other maintance tasks.
447  *
448  * NOTE: Since 2.7.2 this function is run by scheduled task rather
449  * than standard cron.
450  *
451  * @todo MDL-44734 The function will be split up into seperate tasks.
452  */
453 function forum_cron() {
454     global $CFG, $USER, $DB, $PAGE;
456     $site = get_site();
458     // The main renderers.
459     $htmlout = $PAGE->get_renderer('mod_forum', 'email', 'htmlemail');
460     $textout = $PAGE->get_renderer('mod_forum', 'email', 'textemail');
461     $htmldigestfullout = $PAGE->get_renderer('mod_forum', 'emaildigestfull', 'htmlemail');
462     $textdigestfullout = $PAGE->get_renderer('mod_forum', 'emaildigestfull', 'textemail');
463     $htmldigestbasicout = $PAGE->get_renderer('mod_forum', 'emaildigestbasic', 'htmlemail');
464     $textdigestbasicout = $PAGE->get_renderer('mod_forum', 'emaildigestbasic', 'textemail');
466     // All users that are subscribed to any post that needs sending,
467     // please increase $CFG->extramemorylimit on large sites that
468     // send notifications to a large number of users.
469     $users = array();
470     $userscount = 0; // Cached user counter - count($users) in PHP is horribly slow!!!
472     // Status arrays.
473     $mailcount  = array();
474     $errorcount = array();
476     // caches
477     $discussions        = array();
478     $forums             = array();
479     $courses            = array();
480     $coursemodules      = array();
481     $subscribedusers    = array();
482     $messageinboundhandlers = array();
484     // Posts older than 2 days will not be mailed.  This is to avoid the problem where
485     // cron has not been running for a long time, and then suddenly people are flooded
486     // with mail from the past few weeks or months
487     $timenow   = time();
488     $endtime   = $timenow - $CFG->maxeditingtime;
489     $starttime = $endtime - 48 * 3600;   // Two days earlier
491     // Get the list of forum subscriptions for per-user per-forum maildigest settings.
492     $digestsset = $DB->get_recordset('forum_digests', null, '', 'id, userid, forum, maildigest');
493     $digests = array();
494     foreach ($digestsset as $thisrow) {
495         if (!isset($digests[$thisrow->forum])) {
496             $digests[$thisrow->forum] = array();
497         }
498         $digests[$thisrow->forum][$thisrow->userid] = $thisrow->maildigest;
499     }
500     $digestsset->close();
502     // Create the generic messageinboundgenerator.
503     $messageinboundgenerator = new \core\message\inbound\address_manager();
504     $messageinboundgenerator->set_handler('\mod_forum\message\inbound\reply_handler');
506     if ($posts = forum_get_unmailed_posts($starttime, $endtime, $timenow)) {
507         // Mark them all now as being mailed.  It's unlikely but possible there
508         // might be an error later so that a post is NOT actually mailed out,
509         // but since mail isn't crucial, we can accept this risk.  Doing it now
510         // prevents the risk of duplicated mails, which is a worse problem.
512         if (!forum_mark_old_posts_as_mailed($endtime)) {
513             mtrace('Errors occurred while trying to mark some posts as being mailed.');
514             return false;  // Don't continue trying to mail them, in case we are in a cron loop
515         }
517         // checking post validity, and adding users to loop through later
518         foreach ($posts as $pid => $post) {
520             $discussionid = $post->discussion;
521             if (!isset($discussions[$discussionid])) {
522                 if ($discussion = $DB->get_record('forum_discussions', array('id'=> $post->discussion))) {
523                     $discussions[$discussionid] = $discussion;
524                     \mod_forum\subscriptions::fill_subscription_cache($discussion->forum);
525                     \mod_forum\subscriptions::fill_discussion_subscription_cache($discussion->forum);
527                 } else {
528                     mtrace('Could not find discussion ' . $discussionid);
529                     unset($posts[$pid]);
530                     continue;
531                 }
532             }
533             $forumid = $discussions[$discussionid]->forum;
534             if (!isset($forums[$forumid])) {
535                 if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
536                     $forums[$forumid] = $forum;
537                 } else {
538                     mtrace('Could not find forum '.$forumid);
539                     unset($posts[$pid]);
540                     continue;
541                 }
542             }
543             $courseid = $forums[$forumid]->course;
544             if (!isset($courses[$courseid])) {
545                 if ($course = $DB->get_record('course', array('id' => $courseid))) {
546                     $courses[$courseid] = $course;
547                 } else {
548                     mtrace('Could not find course '.$courseid);
549                     unset($posts[$pid]);
550                     continue;
551                 }
552             }
553             if (!isset($coursemodules[$forumid])) {
554                 if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
555                     $coursemodules[$forumid] = $cm;
556                 } else {
557                     mtrace('Could not find course module for forum '.$forumid);
558                     unset($posts[$pid]);
559                     continue;
560                 }
561             }
563             // Save the Inbound Message datakey here to reduce DB queries later.
564             $messageinboundgenerator->set_data($pid);
565             $messageinboundhandlers[$pid] = $messageinboundgenerator->fetch_data_key();
567             // Caching subscribed users of each forum.
568             if (!isset($subscribedusers[$forumid])) {
569                 $modcontext = context_module::instance($coursemodules[$forumid]->id);
570                 if ($subusers = \mod_forum\subscriptions::fetch_subscribed_users($forums[$forumid], 0, $modcontext, 'u.*', true)) {
572                     foreach ($subusers as $postuser) {
573                         // this user is subscribed to this forum
574                         $subscribedusers[$forumid][$postuser->id] = $postuser->id;
575                         $userscount++;
576                         if ($userscount > FORUM_CRON_USER_CACHE) {
577                             // Store minimal user info.
578                             $minuser = new stdClass();
579                             $minuser->id = $postuser->id;
580                             $users[$postuser->id] = $minuser;
581                         } else {
582                             // Cache full user record.
583                             forum_cron_minimise_user_record($postuser);
584                             $users[$postuser->id] = $postuser;
585                         }
586                     }
587                     // Release memory.
588                     unset($subusers);
589                     unset($postuser);
590                 }
591             }
592             $mailcount[$pid] = 0;
593             $errorcount[$pid] = 0;
594         }
595     }
597     if ($users && $posts) {
599         $urlinfo = parse_url($CFG->wwwroot);
600         $hostname = $urlinfo['host'];
602         foreach ($users as $userto) {
603             // Terminate if processing of any account takes longer than 2 minutes.
604             core_php_time_limit::raise(120);
606             mtrace('Processing user ' . $userto->id);
608             // Init user caches - we keep the cache for one cycle only, otherwise it could consume too much memory.
609             if (isset($userto->username)) {
610                 $userto = clone($userto);
611             } else {
612                 $userto = $DB->get_record('user', array('id' => $userto->id));
613                 forum_cron_minimise_user_record($userto);
614             }
615             $userto->viewfullnames = array();
616             $userto->canpost       = array();
617             $userto->markposts     = array();
619             // Setup this user so that the capabilities are cached, and environment matches receiving user.
620             cron_setup_user($userto);
622             // Reset the caches.
623             foreach ($coursemodules as $forumid => $unused) {
624                 $coursemodules[$forumid]->cache       = new stdClass();
625                 $coursemodules[$forumid]->cache->caps = array();
626                 unset($coursemodules[$forumid]->uservisible);
627             }
629             foreach ($posts as $pid => $post) {
630                 $discussion = $discussions[$post->discussion];
631                 $forum      = $forums[$discussion->forum];
632                 $course     = $courses[$forum->course];
633                 $cm         =& $coursemodules[$forum->id];
635                 // Do some checks to see if we can bail out now.
637                 // Only active enrolled users are in the list of subscribers.
638                 // This does not necessarily mean that the user is subscribed to the forum or to the discussion though.
639                 if (!isset($subscribedusers[$forum->id][$userto->id])) {
640                     // The user does not subscribe to this forum.
641                     continue;
642                 }
644                 if (!\mod_forum\subscriptions::is_subscribed($userto->id, $forum, $post->discussion, $coursemodules[$forum->id])) {
645                     // The user does not subscribe to this forum, or to this specific discussion.
646                     continue;
647                 }
649                 if ($subscriptiontime = \mod_forum\subscriptions::fetch_discussion_subscription($forum->id, $userto->id)) {
650                     // Skip posts if the user subscribed to the discussion after it was created.
651                     if (isset($subscriptiontime[$post->discussion]) && ($subscriptiontime[$post->discussion] > $post->created)) {
652                         continue;
653                     }
654                 }
656                 // Don't send email if the forum is Q&A and the user has not posted.
657                 // Initial topics are still mailed.
658                 if ($forum->type == 'qanda' && !forum_get_user_posted_time($discussion->id, $userto->id) && $pid != $discussion->firstpost) {
659                     mtrace('Did not email ' . $userto->id.' because user has not posted in discussion');
660                     continue;
661                 }
663                 // Get info about the sending user.
664                 if (array_key_exists($post->userid, $users)) {
665                     // We might know the user already.
666                     $userfrom = $users[$post->userid];
667                     if (!isset($userfrom->idnumber)) {
668                         // Minimalised user info, fetch full record.
669                         $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
670                         forum_cron_minimise_user_record($userfrom);
671                     }
673                 } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
674                     forum_cron_minimise_user_record($userfrom);
675                     // Fetch only once if possible, we can add it to user list, it will be skipped anyway.
676                     if ($userscount <= FORUM_CRON_USER_CACHE) {
677                         $userscount++;
678                         $users[$userfrom->id] = $userfrom;
679                     }
680                 } else {
681                     mtrace('Could not find user ' . $post->userid . ', author of post ' . $post->id . '. Unable to send message.');
682                     continue;
683                 }
685                 // Note: If we want to check that userto and userfrom are not the same person this is probably the spot to do it.
687                 // Setup global $COURSE properly - needed for roles and languages.
688                 cron_setup_user($userto, $course);
690                 // Fill caches.
691                 if (!isset($userto->viewfullnames[$forum->id])) {
692                     $modcontext = context_module::instance($cm->id);
693                     $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
694                 }
695                 if (!isset($userto->canpost[$discussion->id])) {
696                     $modcontext = context_module::instance($cm->id);
697                     $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
698                 }
699                 if (!isset($userfrom->groups[$forum->id])) {
700                     if (!isset($userfrom->groups)) {
701                         $userfrom->groups = array();
702                         if (isset($users[$userfrom->id])) {
703                             $users[$userfrom->id]->groups = array();
704                         }
705                     }
706                     $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
707                     if (isset($users[$userfrom->id])) {
708                         $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
709                     }
710                 }
712                 // Make sure groups allow this user to see this email.
713                 if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {
714                     // Groups are being used.
715                     if (!groups_group_exists($discussion->groupid)) {
716                         // Can't find group - be safe and don't this message.
717                         continue;
718                     }
720                     if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $modcontext)) {
721                         // Do not send posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS.
722                         continue;
723                     }
724                 }
726                 // Make sure we're allowed to see the post.
727                 if (!forum_user_can_see_post($forum, $discussion, $post, null, $cm)) {
728                     mtrace('User ' . $userto->id .' can not see ' . $post->id . '. Not sending message.');
729                     continue;
730                 }
732                 // OK so we need to send the email.
734                 // Does the user want this post in a digest?  If so postpone it for now.
735                 $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
737                 if ($maildigest > 0) {
738                     // This user wants the mails to be in digest form.
739                     $queue = new stdClass();
740                     $queue->userid       = $userto->id;
741                     $queue->discussionid = $discussion->id;
742                     $queue->postid       = $post->id;
743                     $queue->timemodified = $post->created;
744                     $DB->insert_record('forum_queue', $queue);
745                     continue;
746                 }
748                 // Prepare to actually send the post now, and build up the content.
750                 $cleanforumname = str_replace('"', "'", strip_tags(format_string($forum->name)));
752                 $userfrom->customheaders = array (
753                     // Headers to make emails easier to track.
754                     'List-Id: "'        . $cleanforumname . '" <moodleforum' . $forum->id . '@' . $hostname.'>',
755                     'List-Help: '       . $CFG->wwwroot . '/mod/forum/view.php?f=' . $forum->id,
756                     'Message-ID: '      . forum_get_email_message_id($post->id, $userto->id, $hostname),
757                     'X-Course-Id: '     . $course->id,
758                     'X-Course-Name: '   . format_string($course->fullname, true),
760                     // Headers to help prevent auto-responders.
761                     'Precedence: Bulk',
762                     'X-Auto-Response-Suppress: All',
763                     'Auto-Submitted: auto-generated',
764                 );
766                 if ($post->parent) {
767                     // This post is a reply, so add headers for threading (see MDL-22551).
768                     $userfrom->customheaders[] = 'In-Reply-To: ' . forum_get_email_message_id($post->parent, $userto->id, $hostname);
769                     $userfrom->customheaders[] = 'References: '  . forum_get_email_message_id($post->parent, $userto->id, $hostname);
770                 }
772                 $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
774                 // Generate a reply-to address from using the Inbound Message handler.
775                 $replyaddress = null;
776                 if ($userto->canpost[$discussion->id] && array_key_exists($post->id, $messageinboundhandlers)) {
777                     $messageinboundgenerator->set_data($post->id, $messageinboundhandlers[$post->id]);
778                     $replyaddress = $messageinboundgenerator->generate($userto->id);
779                 }
781                 if (!isset($userto->canpost[$discussion->id])) {
782                     $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
783                 } else {
784                     $canreply = $userto->canpost[$discussion->id];
785                 }
787                 $data = new \mod_forum\output\forum_post_email(
788                         $course,
789                         $cm,
790                         $forum,
791                         $discussion,
792                         $post,
793                         $userfrom,
794                         $userto,
795                         $canreply
796                     );
798                 if (!isset($userto->viewfullnames[$forum->id])) {
799                     $data->viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
800                 } else {
801                     $data->viewfullnames = $userto->viewfullnames[$forum->id];
802                 }
804                 $a = new stdClass();
805                 $a->courseshortname = $data->get_coursename();
806                 $a->forumname = $cleanforumname;
807                 $a->subject = $data->get_subject();
808                 $postsubject = html_to_text(get_string('postmailsubject', 'forum', $a), 0);
810                 // Send the post now!
811                 mtrace('Sending ', '');
813                 $eventdata = new \core\message\message();
814                 $eventdata->component           = 'mod_forum';
815                 $eventdata->name                = 'posts';
816                 $eventdata->userfrom            = $userfrom;
817                 $eventdata->userto              = $userto;
818                 $eventdata->subject             = $postsubject;
819                 $eventdata->fullmessage         = $textout->render($data);
820                 $eventdata->fullmessageformat   = FORMAT_PLAIN;
821                 $eventdata->fullmessagehtml     = $htmlout->render($data);
822                 $eventdata->notification        = 1;
823                 $eventdata->replyto             = $replyaddress;
824                 if (!empty($replyaddress)) {
825                     // Add extra text to email messages if they can reply back.
826                     $textfooter = "\n\n" . get_string('replytopostbyemail', 'mod_forum');
827                     $htmlfooter = html_writer::tag('p', get_string('replytopostbyemail', 'mod_forum'));
828                     $additionalcontent = array('fullmessage' => array('footer' => $textfooter),
829                                      'fullmessagehtml' => array('footer' => $htmlfooter));
830                     $eventdata->set_additional_content('email', $additionalcontent);
831                 }
833                 // If forum_replytouser is not set then send mail using the noreplyaddress.
834                 if (empty($CFG->forum_replytouser)) {
835                     $eventdata->userfrom = core_user::get_noreply_user();
836                 }
838                 $smallmessagestrings = new stdClass();
839                 $smallmessagestrings->user          = fullname($userfrom);
840                 $smallmessagestrings->forumname     = "$shortname: " . format_string($forum->name, true) . ": " . $discussion->name;
841                 $smallmessagestrings->message       = $post->message;
843                 // Make sure strings are in message recipients language.
844                 $eventdata->smallmessage = get_string_manager()->get_string('smallmessage', 'forum', $smallmessagestrings, $userto->lang);
846                 $contexturl = new moodle_url('/mod/forum/discuss.php', array('d' => $discussion->id), 'p' . $post->id);
847                 $eventdata->contexturl = $contexturl->out();
848                 $eventdata->contexturlname = $discussion->name;
850                 $mailresult = message_send($eventdata);
851                 if (!$mailresult) {
852                     mtrace("Error: mod/forum/lib.php forum_cron(): Could not send out mail for id $post->id to user $userto->id".
853                             " ($userto->email) .. not trying again.");
854                     $errorcount[$post->id]++;
855                 } else {
856                     $mailcount[$post->id]++;
858                     // Mark post as read if forum_usermarksread is set off.
859                     if (!$CFG->forum_usermarksread) {
860                         $userto->markposts[$post->id] = $post->id;
861                     }
862                 }
864                 mtrace('post ' . $post->id . ': ' . $post->subject);
865             }
867             // Mark processed posts as read.
868             forum_tp_mark_posts_read($userto, $userto->markposts);
869             unset($userto);
870         }
871     }
873     if ($posts) {
874         foreach ($posts as $post) {
875             mtrace($mailcount[$post->id]." users were sent post $post->id, '$post->subject'");
876             if ($errorcount[$post->id]) {
877                 $DB->set_field('forum_posts', 'mailed', FORUM_MAILED_ERROR, array('id' => $post->id));
878             }
879         }
880     }
882     // release some memory
883     unset($subscribedusers);
884     unset($mailcount);
885     unset($errorcount);
887     cron_setup_user();
889     $sitetimezone = core_date::get_server_timezone();
891     // Now see if there are any digest mails waiting to be sent, and if we should send them
893     mtrace('Starting digest processing...');
895     core_php_time_limit::raise(300); // terminate if not able to fetch all digests in 5 minutes
897     if (!isset($CFG->digestmailtimelast)) {    // To catch the first time
898         set_config('digestmailtimelast', 0);
899     }
901     $timenow = time();
902     $digesttime = usergetmidnight($timenow, $sitetimezone) + ($CFG->digestmailtime * 3600);
904     // Delete any really old ones (normally there shouldn't be any)
905     $weekago = $timenow - (7 * 24 * 3600);
906     $DB->delete_records_select('forum_queue', "timemodified < ?", array($weekago));
907     mtrace ('Cleaned old digest records');
909     if ($CFG->digestmailtimelast < $digesttime and $timenow > $digesttime) {
911         mtrace('Sending forum digests: '.userdate($timenow, '', $sitetimezone));
913         $digestposts_rs = $DB->get_recordset_select('forum_queue', "timemodified < ?", array($digesttime));
915         if ($digestposts_rs->valid()) {
917             // We have work to do
918             $usermailcount = 0;
920             //caches - reuse the those filled before too
921             $discussionposts = array();
922             $userdiscussions = array();
924             foreach ($digestposts_rs as $digestpost) {
925                 if (!isset($posts[$digestpost->postid])) {
926                     if ($post = $DB->get_record('forum_posts', array('id' => $digestpost->postid))) {
927                         $posts[$digestpost->postid] = $post;
928                     } else {
929                         continue;
930                     }
931                 }
932                 $discussionid = $digestpost->discussionid;
933                 if (!isset($discussions[$discussionid])) {
934                     if ($discussion = $DB->get_record('forum_discussions', array('id' => $discussionid))) {
935                         $discussions[$discussionid] = $discussion;
936                     } else {
937                         continue;
938                     }
939                 }
940                 $forumid = $discussions[$discussionid]->forum;
941                 if (!isset($forums[$forumid])) {
942                     if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
943                         $forums[$forumid] = $forum;
944                     } else {
945                         continue;
946                     }
947                 }
949                 $courseid = $forums[$forumid]->course;
950                 if (!isset($courses[$courseid])) {
951                     if ($course = $DB->get_record('course', array('id' => $courseid))) {
952                         $courses[$courseid] = $course;
953                     } else {
954                         continue;
955                     }
956                 }
958                 if (!isset($coursemodules[$forumid])) {
959                     if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
960                         $coursemodules[$forumid] = $cm;
961                     } else {
962                         continue;
963                     }
964                 }
965                 $userdiscussions[$digestpost->userid][$digestpost->discussionid] = $digestpost->discussionid;
966                 $discussionposts[$digestpost->discussionid][$digestpost->postid] = $digestpost->postid;
967             }
968             $digestposts_rs->close(); /// Finished iteration, let's close the resultset
970             // Data collected, start sending out emails to each user
971             foreach ($userdiscussions as $userid => $thesediscussions) {
973                 core_php_time_limit::raise(120); // terminate if processing of any account takes longer than 2 minutes
975                 cron_setup_user();
977                 mtrace(get_string('processingdigest', 'forum', $userid), '... ');
979                 // First of all delete all the queue entries for this user
980                 $DB->delete_records_select('forum_queue', "userid = ? AND timemodified < ?", array($userid, $digesttime));
982                 // Init user caches - we keep the cache for one cycle only,
983                 // otherwise it would unnecessarily consume memory.
984                 if (array_key_exists($userid, $users) and isset($users[$userid]->username)) {
985                     $userto = clone($users[$userid]);
986                 } else {
987                     $userto = $DB->get_record('user', array('id' => $userid));
988                     forum_cron_minimise_user_record($userto);
989                 }
990                 $userto->viewfullnames = array();
991                 $userto->canpost       = array();
992                 $userto->markposts     = array();
994                 // Override the language and timezone of the "current" user, so that
995                 // mail is customised for the receiver.
996                 cron_setup_user($userto);
998                 $postsubject = get_string('digestmailsubject', 'forum', format_string($site->shortname, true));
1000                 $headerdata = new stdClass();
1001                 $headerdata->sitename = format_string($site->fullname, true);
1002                 $headerdata->userprefs = $CFG->wwwroot.'/user/edit.php?id='.$userid.'&amp;course='.$site->id;
1004                 $posttext = get_string('digestmailheader', 'forum', $headerdata)."\n\n";
1005                 $headerdata->userprefs = '<a target="_blank" href="'.$headerdata->userprefs.'">'.get_string('digestmailprefs', 'forum').'</a>';
1007                 $posthtml = "<head>";
1008 /*                foreach ($CFG->stylesheets as $stylesheet) {
1009                     //TODO: MDL-21120
1010                     $posthtml .= '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'" />'."\n";
1011                 }*/
1012                 $posthtml .= "</head>\n<body id=\"email\">\n";
1013                 $posthtml .= '<p>'.get_string('digestmailheader', 'forum', $headerdata).'</p><br /><hr size="1" noshade="noshade" />';
1015                 foreach ($thesediscussions as $discussionid) {
1017                     core_php_time_limit::raise(120);   // to be reset for each post
1019                     $discussion = $discussions[$discussionid];
1020                     $forum      = $forums[$discussion->forum];
1021                     $course     = $courses[$forum->course];
1022                     $cm         = $coursemodules[$forum->id];
1024                     //override language
1025                     cron_setup_user($userto, $course);
1027                     // Fill caches
1028                     if (!isset($userto->viewfullnames[$forum->id])) {
1029                         $modcontext = context_module::instance($cm->id);
1030                         $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
1031                     }
1032                     if (!isset($userto->canpost[$discussion->id])) {
1033                         $modcontext = context_module::instance($cm->id);
1034                         $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1035                     }
1037                     $strforums      = get_string('forums', 'forum');
1038                     $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
1039                     $canreply       = $userto->canpost[$discussion->id];
1040                     $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1042                     $posttext .= "\n \n";
1043                     $posttext .= '=====================================================================';
1044                     $posttext .= "\n \n";
1045                     $posttext .= "$shortname -> $strforums -> ".format_string($forum->name,true);
1046                     if ($discussion->name != $forum->name) {
1047                         $posttext  .= " -> ".format_string($discussion->name,true);
1048                     }
1049                     $posttext .= "\n";
1050                     $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1051                     $posttext .= "\n";
1053                     $posthtml .= "<p><font face=\"sans-serif\">".
1054                     "<a target=\"_blank\" href=\"$CFG->wwwroot/course/view.php?id=$course->id\">$shortname</a> -> ".
1055                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/index.php?id=$course->id\">$strforums</a> -> ".
1056                     "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/view.php?f=$forum->id\">".format_string($forum->name,true)."</a>";
1057                     if ($discussion->name == $forum->name) {
1058                         $posthtml .= "</font></p>";
1059                     } else {
1060                         $posthtml .= " -> <a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id\">".format_string($discussion->name,true)."</a></font></p>";
1061                     }
1062                     $posthtml .= '<p>';
1064                     $postsarray = $discussionposts[$discussionid];
1065                     sort($postsarray);
1067                     foreach ($postsarray as $postid) {
1068                         $post = $posts[$postid];
1070                         if (array_key_exists($post->userid, $users)) { // we might know him/her already
1071                             $userfrom = $users[$post->userid];
1072                             if (!isset($userfrom->idnumber)) {
1073                                 $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
1074                                 forum_cron_minimise_user_record($userfrom);
1075                             }
1077                         } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
1078                             forum_cron_minimise_user_record($userfrom);
1079                             if ($userscount <= FORUM_CRON_USER_CACHE) {
1080                                 $userscount++;
1081                                 $users[$userfrom->id] = $userfrom;
1082                             }
1084                         } else {
1085                             mtrace('Could not find user '.$post->userid);
1086                             continue;
1087                         }
1089                         if (!isset($userfrom->groups[$forum->id])) {
1090                             if (!isset($userfrom->groups)) {
1091                                 $userfrom->groups = array();
1092                                 if (isset($users[$userfrom->id])) {
1093                                     $users[$userfrom->id]->groups = array();
1094                                 }
1095                             }
1096                             $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
1097                             if (isset($users[$userfrom->id])) {
1098                                 $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
1099                             }
1100                         }
1102                         // Headers to help prevent auto-responders.
1103                         $userfrom->customheaders = array(
1104                                 "Precedence: Bulk",
1105                                 'X-Auto-Response-Suppress: All',
1106                                 'Auto-Submitted: auto-generated',
1107                             );
1109                         $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
1110                         if (!isset($userto->canpost[$discussion->id])) {
1111                             $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1112                         } else {
1113                             $canreply = $userto->canpost[$discussion->id];
1114                         }
1116                         $data = new \mod_forum\output\forum_post_email(
1117                                 $course,
1118                                 $cm,
1119                                 $forum,
1120                                 $discussion,
1121                                 $post,
1122                                 $userfrom,
1123                                 $userto,
1124                                 $canreply
1125                             );
1127                         if (!isset($userto->viewfullnames[$forum->id])) {
1128                             $data->viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
1129                         } else {
1130                             $data->viewfullnames = $userto->viewfullnames[$forum->id];
1131                         }
1133                         if ($maildigest == 2) {
1134                             // Subjects and link only.
1135                             $posttext .= $textdigestbasicout->render($data);
1136                             $posthtml .= $htmldigestbasicout->render($data);
1137                         } else {
1138                             // The full treatment.
1139                             $posttext .= $textdigestfullout->render($data);
1140                             $posthtml .= $htmldigestfullout->render($data);
1142                             // Create an array of postid's for this user to mark as read.
1143                             if (!$CFG->forum_usermarksread) {
1144                                 $userto->markposts[$post->id] = $post->id;
1145                             }
1146                         }
1147                     }
1148                     $footerlinks = array();
1149                     if ($canunsubscribe) {
1150                         $footerlinks[] = "<a href=\"$CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id\">" . get_string("unsubscribe", "forum") . "</a>";
1151                     } else {
1152                         $footerlinks[] = get_string("everyoneissubscribed", "forum");
1153                     }
1154                     $footerlinks[] = "<a href='{$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}'>" . get_string("digestmailpost", "forum") . '</a>';
1155                     $posthtml .= "\n<div class='mdl-right'><font size=\"1\">" . implode('&nbsp;', $footerlinks) . '</font></div>';
1156                     $posthtml .= '<hr size="1" noshade="noshade" /></p>';
1157                 }
1158                 $posthtml .= '</body>';
1160                 if (empty($userto->mailformat) || $userto->mailformat != 1) {
1161                     // This user DOESN'T want to receive HTML
1162                     $posthtml = '';
1163                 }
1165                 $attachment = $attachname='';
1166                 // Directly email forum digests rather than sending them via messaging, use the
1167                 // site shortname as 'from name', the noreply address will be used by email_to_user.
1168                 $mailresult = email_to_user($userto, $site->shortname, $postsubject, $posttext, $posthtml, $attachment, $attachname);
1170                 if (!$mailresult) {
1171                     mtrace("ERROR: mod/forum/cron.php: Could not send out digest mail to user $userto->id ".
1172                         "($userto->email)... not trying again.");
1173                 } else {
1174                     mtrace("success.");
1175                     $usermailcount++;
1177                     // Mark post as read if forum_usermarksread is set off
1178                     forum_tp_mark_posts_read($userto, $userto->markposts);
1179                 }
1180             }
1181         }
1182     /// We have finishied all digest emails, update $CFG->digestmailtimelast
1183         set_config('digestmailtimelast', $timenow);
1184     }
1186     cron_setup_user();
1188     if (!empty($usermailcount)) {
1189         mtrace(get_string('digestsentusers', 'forum', $usermailcount));
1190     }
1192     if (!empty($CFG->forum_lastreadclean)) {
1193         $timenow = time();
1194         if ($CFG->forum_lastreadclean + (24*3600) < $timenow) {
1195             set_config('forum_lastreadclean', $timenow);
1196             mtrace('Removing old forum read tracking info...');
1197             forum_tp_clean_read_records();
1198         }
1199     } else {
1200         set_config('forum_lastreadclean', time());
1201     }
1203     return true;
1206 /**
1207  *
1208  * @param object $course
1209  * @param object $user
1210  * @param object $mod TODO this is not used in this function, refactor
1211  * @param object $forum
1212  * @return object A standard object with 2 variables: info (number of posts for this user) and time (last modified)
1213  */
1214 function forum_user_outline($course, $user, $mod, $forum) {
1215     global $CFG;
1216     require_once("$CFG->libdir/gradelib.php");
1217     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1218     if (empty($grades->items[0]->grades)) {
1219         $grade = false;
1220     } else {
1221         $grade = reset($grades->items[0]->grades);
1222     }
1224     $count = forum_count_user_posts($forum->id, $user->id);
1226     if ($count && $count->postcount > 0) {
1227         $result = new stdClass();
1228         $result->info = get_string("numposts", "forum", $count->postcount);
1229         $result->time = $count->lastpost;
1230         if ($grade) {
1231             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1232         }
1233         return $result;
1234     } else if ($grade) {
1235         $result = new stdClass();
1236         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1238         //datesubmitted == time created. dategraded == time modified or time overridden
1239         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1240         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1241         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1242             $result->time = $grade->dategraded;
1243         } else {
1244             $result->time = $grade->datesubmitted;
1245         }
1247         return $result;
1248     }
1249     return NULL;
1253 /**
1254  * @global object
1255  * @global object
1256  * @param object $coure
1257  * @param object $user
1258  * @param object $mod
1259  * @param object $forum
1260  */
1261 function forum_user_complete($course, $user, $mod, $forum) {
1262     global $CFG,$USER, $OUTPUT;
1263     require_once("$CFG->libdir/gradelib.php");
1265     $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1266     if (!empty($grades->items[0]->grades)) {
1267         $grade = reset($grades->items[0]->grades);
1268         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1269         if ($grade->str_feedback) {
1270             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1271         }
1272     }
1274     if ($posts = forum_get_user_posts($forum->id, $user->id)) {
1276         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $course->id)) {
1277             print_error('invalidcoursemodule');
1278         }
1279         $discussions = forum_get_user_involved_discussions($forum->id, $user->id);
1281         foreach ($posts as $post) {
1282             if (!isset($discussions[$post->discussion])) {
1283                 continue;
1284             }
1285             $discussion = $discussions[$post->discussion];
1287             forum_print_post($post, $discussion, $forum, $cm, $course, false, false, false);
1288         }
1289     } else {
1290         echo "<p>".get_string("noposts", "forum")."</p>";
1291     }
1294 /**
1295  * Filters the forum discussions according to groups membership and config.
1296  *
1297  * @since  Moodle 2.8, 2.7.1, 2.6.4
1298  * @param  array $discussions Discussions with new posts array
1299  * @return array Forums with the number of new posts
1300  */
1301 function forum_filter_user_groups_discussions($discussions) {
1303     // Group the remaining discussions posts by their forumid.
1304     $filteredforums = array();
1306     // Discard not visible groups.
1307     foreach ($discussions as $discussion) {
1309         // Course data is already cached.
1310         $instances = get_fast_modinfo($discussion->course)->get_instances();
1311         $forum = $instances['forum'][$discussion->forum];
1313         // Continue if the user should not see this discussion.
1314         if (!forum_is_user_group_discussion($forum, $discussion->groupid)) {
1315             continue;
1316         }
1318         // Grouping results by forum.
1319         if (empty($filteredforums[$forum->instance])) {
1320             $filteredforums[$forum->instance] = new stdClass();
1321             $filteredforums[$forum->instance]->id = $forum->id;
1322             $filteredforums[$forum->instance]->count = 0;
1323         }
1324         $filteredforums[$forum->instance]->count += $discussion->count;
1326     }
1328     return $filteredforums;
1331 /**
1332  * Returns whether the discussion group is visible by the current user or not.
1333  *
1334  * @since Moodle 2.8, 2.7.1, 2.6.4
1335  * @param cm_info $cm The discussion course module
1336  * @param int $discussiongroupid The discussion groupid
1337  * @return bool
1338  */
1339 function forum_is_user_group_discussion(cm_info $cm, $discussiongroupid) {
1341     if ($discussiongroupid == -1 || $cm->effectivegroupmode != SEPARATEGROUPS) {
1342         return true;
1343     }
1345     if (isguestuser()) {
1346         return false;
1347     }
1349     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id)) ||
1350             in_array($discussiongroupid, $cm->get_modinfo()->get_groups($cm->groupingid))) {
1351         return true;
1352     }
1354     return false;
1357 /**
1358  * @global object
1359  * @global object
1360  * @global object
1361  * @param array $courses
1362  * @param array $htmlarray
1363  */
1364 function forum_print_overview($courses,&$htmlarray) {
1365     global $USER, $CFG, $DB, $SESSION;
1367     if (empty($courses) || !is_array($courses) || count($courses) == 0) {
1368         return array();
1369     }
1371     if (!$forums = get_all_instances_in_courses('forum',$courses)) {
1372         return;
1373     }
1375     // Courses to search for new posts
1376     $coursessqls = array();
1377     $params = array();
1378     foreach ($courses as $course) {
1380         // If the user has never entered into the course all posts are pending
1381         if ($course->lastaccess == 0) {
1382             $coursessqls[] = '(d.course = ?)';
1383             $params[] = $course->id;
1385         // Only posts created after the course last access
1386         } else {
1387             $coursessqls[] = '(d.course = ? AND p.created > ?)';
1388             $params[] = $course->id;
1389             $params[] = $course->lastaccess;
1390         }
1391     }
1392     $params[] = $USER->id;
1393     $coursessql = implode(' OR ', $coursessqls);
1395     $sql = "SELECT d.id, d.forum, d.course, d.groupid, COUNT(*) as count "
1396                 .'FROM {forum_discussions} d '
1397                 .'JOIN {forum_posts} p ON p.discussion = d.id '
1398                 ."WHERE ($coursessql) "
1399                 .'AND p.userid != ? '
1400                 .'AND (d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?)) '
1401                 .'GROUP BY d.id, d.forum, d.course, d.groupid '
1402                 .'ORDER BY d.course, d.forum';
1403     $params[] = time();
1404     $params[] = time();
1406     // Avoid warnings.
1407     if (!$discussions = $DB->get_records_sql($sql, $params)) {
1408         $discussions = array();
1409     }
1411     $forumsnewposts = forum_filter_user_groups_discussions($discussions);
1413     // also get all forum tracking stuff ONCE.
1414     $trackingforums = array();
1415     foreach ($forums as $forum) {
1416         if (forum_tp_can_track_forums($forum)) {
1417             $trackingforums[$forum->id] = $forum;
1418         }
1419     }
1421     if (count($trackingforums) > 0) {
1422         $cutoffdate = isset($CFG->forum_oldpostdays) ? (time() - ($CFG->forum_oldpostdays*24*60*60)) : 0;
1423         $sql = 'SELECT d.forum,d.course,COUNT(p.id) AS count '.
1424             ' FROM {forum_posts} p '.
1425             ' JOIN {forum_discussions} d ON p.discussion = d.id '.
1426             ' LEFT JOIN {forum_read} r ON r.postid = p.id AND r.userid = ? WHERE (';
1427         $params = array($USER->id);
1429         foreach ($trackingforums as $track) {
1430             $sql .= '(d.forum = ? AND (d.groupid = -1 OR d.groupid = 0 OR d.groupid = ?)) OR ';
1431             $params[] = $track->id;
1432             if (isset($SESSION->currentgroup[$track->course])) {
1433                 $groupid =  $SESSION->currentgroup[$track->course];
1434             } else {
1435                 // get first groupid
1436                 $groupids = groups_get_all_groups($track->course, $USER->id);
1437                 if ($groupids) {
1438                     reset($groupids);
1439                     $groupid = key($groupids);
1440                     $SESSION->currentgroup[$track->course] = $groupid;
1441                 } else {
1442                     $groupid = 0;
1443                 }
1444                 unset($groupids);
1445             }
1446             $params[] = $groupid;
1447         }
1448         $sql = substr($sql,0,-3); // take off the last OR
1449         $sql .= ') AND p.modified >= ? AND r.id is NULL ';
1450         $sql .= 'AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)) ';
1451         $sql .= 'GROUP BY d.forum,d.course';
1452         $params[] = $cutoffdate;
1453         $params[] = time();
1454         $params[] = time();
1456         if (!$unread = $DB->get_records_sql($sql, $params)) {
1457             $unread = array();
1458         }
1459     } else {
1460         $unread = array();
1461     }
1463     if (empty($unread) and empty($forumsnewposts)) {
1464         return;
1465     }
1467     $strforum = get_string('modulename','forum');
1469     foreach ($forums as $forum) {
1470         $str = '';
1471         $count = 0;
1472         $thisunread = 0;
1473         $showunread = false;
1474         // either we have something from logs, or trackposts, or nothing.
1475         if (array_key_exists($forum->id, $forumsnewposts) && !empty($forumsnewposts[$forum->id])) {
1476             $count = $forumsnewposts[$forum->id]->count;
1477         }
1478         if (array_key_exists($forum->id,$unread)) {
1479             $thisunread = $unread[$forum->id]->count;
1480             $showunread = true;
1481         }
1482         if ($count > 0 || $thisunread > 0) {
1483             $str .= '<div class="overview forum"><div class="name">'.$strforum.': <a title="'.$strforum.'" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.
1484                 $forum->name.'</a></div>';
1485             $str .= '<div class="info"><span class="postsincelogin">';
1486             $str .= get_string('overviewnumpostssince', 'forum', $count)."</span>";
1487             if (!empty($showunread)) {
1488                 $str .= '<div class="unreadposts">'.get_string('overviewnumunread', 'forum', $thisunread).'</div>';
1489             }
1490             $str .= '</div></div>';
1491         }
1492         if (!empty($str)) {
1493             if (!array_key_exists($forum->course,$htmlarray)) {
1494                 $htmlarray[$forum->course] = array();
1495             }
1496             if (!array_key_exists('forum',$htmlarray[$forum->course])) {
1497                 $htmlarray[$forum->course]['forum'] = ''; // initialize, avoid warnings
1498             }
1499             $htmlarray[$forum->course]['forum'] .= $str;
1500         }
1501     }
1504 /**
1505  * Given a course and a date, prints a summary of all the new
1506  * messages posted in the course since that date
1507  *
1508  * @global object
1509  * @global object
1510  * @global object
1511  * @uses CONTEXT_MODULE
1512  * @uses VISIBLEGROUPS
1513  * @param object $course
1514  * @param bool $viewfullnames capability
1515  * @param int $timestart
1516  * @return bool success
1517  */
1518 function forum_print_recent_activity($course, $viewfullnames, $timestart) {
1519     global $CFG, $USER, $DB, $OUTPUT;
1521     // do not use log table if possible, it may be huge and is expensive to join with other tables
1523     $allnamefields = user_picture::fields('u', null, 'duserid');
1524     if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
1525                                               d.timestart, d.timeend, $allnamefields
1526                                          FROM {forum_posts} p
1527                                               JOIN {forum_discussions} d ON d.id = p.discussion
1528                                               JOIN {forum} f             ON f.id = d.forum
1529                                               JOIN {user} u              ON u.id = p.userid
1530                                         WHERE p.created > ? AND f.course = ?
1531                                      ORDER BY p.id ASC", array($timestart, $course->id))) { // order by initial posting date
1532          return false;
1533     }
1535     $modinfo = get_fast_modinfo($course);
1537     $groupmodes = array();
1538     $cms    = array();
1540     $strftimerecent = get_string('strftimerecent');
1542     $printposts = array();
1543     foreach ($posts as $post) {
1544         if (!isset($modinfo->instances['forum'][$post->forum])) {
1545             // not visible
1546             continue;
1547         }
1548         $cm = $modinfo->instances['forum'][$post->forum];
1549         if (!$cm->uservisible) {
1550             continue;
1551         }
1552         $context = context_module::instance($cm->id);
1554         if (!has_capability('mod/forum:viewdiscussion', $context)) {
1555             continue;
1556         }
1558         if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
1559           and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
1560             if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1561                 continue;
1562             }
1563         }
1565         // Check that the user can see the discussion.
1566         if (forum_is_user_group_discussion($cm, $post->groupid)) {
1567             $printposts[] = $post;
1568         }
1570     }
1571     unset($posts);
1573     if (!$printposts) {
1574         return false;
1575     }
1577     echo $OUTPUT->heading(get_string('newforumposts', 'forum').':', 3);
1578     echo "\n<ul class='unlist'>\n";
1580     foreach ($printposts as $post) {
1581         $subjectclass = empty($post->parent) ? ' bold' : '';
1583         echo '<li><div class="head">'.
1584                '<div class="date">'.userdate($post->modified, $strftimerecent).'</div>'.
1585                '<div class="name">'.fullname($post, $viewfullnames).'</div>'.
1586              '</div>';
1587         echo '<div class="info'.$subjectclass.'">';
1588         if (empty($post->parent)) {
1589             echo '"<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
1590         } else {
1591             echo '"<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'&amp;parent='.$post->parent.'#p'.$post->id.'">';
1592         }
1593         $post->subject = break_up_long_words(format_string($post->subject, true));
1594         echo $post->subject;
1595         echo "</a>\"</div></li>\n";
1596     }
1598     echo "</ul>\n";
1600     return true;
1603 /**
1604  * Return grade for given user or all users.
1605  *
1606  * @global object
1607  * @global object
1608  * @param object $forum
1609  * @param int $userid optional user id, 0 means all users
1610  * @return array array of grades, false if none
1611  */
1612 function forum_get_user_grades($forum, $userid = 0) {
1613     global $CFG;
1615     require_once($CFG->dirroot.'/rating/lib.php');
1617     $ratingoptions = new stdClass;
1618     $ratingoptions->component = 'mod_forum';
1619     $ratingoptions->ratingarea = 'post';
1621     //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?
1622     $ratingoptions->modulename = 'forum';
1623     $ratingoptions->moduleid   = $forum->id;
1624     $ratingoptions->userid = $userid;
1625     $ratingoptions->aggregationmethod = $forum->assessed;
1626     $ratingoptions->scaleid = $forum->scale;
1627     $ratingoptions->itemtable = 'forum_posts';
1628     $ratingoptions->itemtableusercolumn = 'userid';
1630     $rm = new rating_manager();
1631     return $rm->get_user_grades($ratingoptions);
1634 /**
1635  * Update activity grades
1636  *
1637  * @category grade
1638  * @param object $forum
1639  * @param int $userid specific user only, 0 means all
1640  * @param boolean $nullifnone return null if grade does not exist
1641  * @return void
1642  */
1643 function forum_update_grades($forum, $userid=0, $nullifnone=true) {
1644     global $CFG, $DB;
1645     require_once($CFG->libdir.'/gradelib.php');
1647     if (!$forum->assessed) {
1648         forum_grade_item_update($forum);
1650     } else if ($grades = forum_get_user_grades($forum, $userid)) {
1651         forum_grade_item_update($forum, $grades);
1653     } else if ($userid and $nullifnone) {
1654         $grade = new stdClass();
1655         $grade->userid   = $userid;
1656         $grade->rawgrade = NULL;
1657         forum_grade_item_update($forum, $grade);
1659     } else {
1660         forum_grade_item_update($forum);
1661     }
1664 /**
1665  * Create/update grade item for given forum
1666  *
1667  * @category grade
1668  * @uses GRADE_TYPE_NONE
1669  * @uses GRADE_TYPE_VALUE
1670  * @uses GRADE_TYPE_SCALE
1671  * @param stdClass $forum Forum object with extra cmidnumber
1672  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1673  * @return int 0 if ok
1674  */
1675 function forum_grade_item_update($forum, $grades=NULL) {
1676     global $CFG;
1677     if (!function_exists('grade_update')) { //workaround for buggy PHP versions
1678         require_once($CFG->libdir.'/gradelib.php');
1679     }
1681     $params = array('itemname'=>$forum->name, 'idnumber'=>$forum->cmidnumber);
1683     if (!$forum->assessed or $forum->scale == 0) {
1684         $params['gradetype'] = GRADE_TYPE_NONE;
1686     } else if ($forum->scale > 0) {
1687         $params['gradetype'] = GRADE_TYPE_VALUE;
1688         $params['grademax']  = $forum->scale;
1689         $params['grademin']  = 0;
1691     } else if ($forum->scale < 0) {
1692         $params['gradetype'] = GRADE_TYPE_SCALE;
1693         $params['scaleid']   = -$forum->scale;
1694     }
1696     if ($grades  === 'reset') {
1697         $params['reset'] = true;
1698         $grades = NULL;
1699     }
1701     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, $grades, $params);
1704 /**
1705  * Delete grade item for given forum
1706  *
1707  * @category grade
1708  * @param stdClass $forum Forum object
1709  * @return grade_item
1710  */
1711 function forum_grade_item_delete($forum) {
1712     global $CFG;
1713     require_once($CFG->libdir.'/gradelib.php');
1715     return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, NULL, array('deleted'=>1));
1719 /**
1720  * This function returns if a scale is being used by one forum
1721  *
1722  * @global object
1723  * @param int $forumid
1724  * @param int $scaleid negative number
1725  * @return bool
1726  */
1727 function forum_scale_used ($forumid,$scaleid) {
1728     global $DB;
1729     $return = false;
1731     $rec = $DB->get_record("forum",array("id" => "$forumid","scale" => "-$scaleid"));
1733     if (!empty($rec) && !empty($scaleid)) {
1734         $return = true;
1735     }
1737     return $return;
1740 /**
1741  * Checks if scale is being used by any instance of forum
1742  *
1743  * This is used to find out if scale used anywhere
1744  *
1745  * @global object
1746  * @param $scaleid int
1747  * @return boolean True if the scale is used by any forum
1748  */
1749 function forum_scale_used_anywhere($scaleid) {
1750     global $DB;
1751     if ($scaleid and $DB->record_exists('forum', array('scale' => -$scaleid))) {
1752         return true;
1753     } else {
1754         return false;
1755     }
1758 // SQL FUNCTIONS ///////////////////////////////////////////////////////////
1760 /**
1761  * Gets a post with all info ready for forum_print_post
1762  * Most of these joins are just to get the forum id
1763  *
1764  * @global object
1765  * @global object
1766  * @param int $postid
1767  * @return mixed array of posts or false
1768  */
1769 function forum_get_post_full($postid) {
1770     global $CFG, $DB;
1772     $allnames = get_all_user_name_fields(true, 'u');
1773     return $DB->get_record_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1774                              FROM {forum_posts} p
1775                                   JOIN {forum_discussions} d ON p.discussion = d.id
1776                                   LEFT JOIN {user} u ON p.userid = u.id
1777                             WHERE p.id = ?", array($postid));
1780 /**
1781  * Gets all posts in discussion including top parent.
1782  *
1783  * @global object
1784  * @global object
1785  * @global object
1786  * @param int $discussionid
1787  * @param string $sort
1788  * @param bool $tracking does user track the forum?
1789  * @return array of posts
1790  */
1791 function forum_get_all_discussion_posts($discussionid, $sort, $tracking=false) {
1792     global $CFG, $DB, $USER;
1794     $tr_sel  = "";
1795     $tr_join = "";
1796     $params = array();
1798     if ($tracking) {
1799         $now = time();
1800         $cutoffdate = $now - ($CFG->forum_oldpostdays * 24 * 3600);
1801         $tr_sel  = ", fr.id AS postread";
1802         $tr_join = "LEFT JOIN {forum_read} fr ON (fr.postid = p.id AND fr.userid = ?)";
1803         $params[] = $USER->id;
1804     }
1806     $allnames = get_all_user_name_fields(true, 'u');
1807     $params[] = $discussionid;
1808     if (!$posts = $DB->get_records_sql("SELECT p.*, $allnames, u.email, u.picture, u.imagealt $tr_sel
1809                                      FROM {forum_posts} p
1810                                           LEFT JOIN {user} u ON p.userid = u.id
1811                                           $tr_join
1812                                     WHERE p.discussion = ?
1813                                  ORDER BY $sort", $params)) {
1814         return array();
1815     }
1817     foreach ($posts as $pid=>$p) {
1818         if ($tracking) {
1819             if (forum_tp_is_post_old($p)) {
1820                  $posts[$pid]->postread = true;
1821             }
1822         }
1823         if (!$p->parent) {
1824             continue;
1825         }
1826         if (!isset($posts[$p->parent])) {
1827             continue; // parent does not exist??
1828         }
1829         if (!isset($posts[$p->parent]->children)) {
1830             $posts[$p->parent]->children = array();
1831         }
1832         $posts[$p->parent]->children[$pid] =& $posts[$pid];
1833     }
1835     // Start with the last child of the first post.
1836     $post = &$posts[reset($posts)->id];
1838     $lastpost = false;
1839     while (!$lastpost) {
1840         if (!isset($post->children)) {
1841             $post->lastpost = true;
1842             $lastpost = true;
1843         } else {
1844              // Go to the last child of this post.
1845             $post = &$posts[end($post->children)->id];
1846         }
1847     }
1849     return $posts;
1852 /**
1853  * An array of forum objects that the user is allowed to read/search through.
1854  *
1855  * @global object
1856  * @global object
1857  * @global object
1858  * @param int $userid
1859  * @param int $courseid if 0, we look for forums throughout the whole site.
1860  * @return array of forum objects, or false if no matches
1861  *         Forum objects have the following attributes:
1862  *         id, type, course, cmid, cmvisible, cmgroupmode, accessallgroups,
1863  *         viewhiddentimedposts
1864  */
1865 function forum_get_readable_forums($userid, $courseid=0) {
1867     global $CFG, $DB, $USER;
1868     require_once($CFG->dirroot.'/course/lib.php');
1870     if (!$forummod = $DB->get_record('modules', array('name' => 'forum'))) {
1871         print_error('notinstalled', 'forum');
1872     }
1874     if ($courseid) {
1875         $courses = $DB->get_records('course', array('id' => $courseid));
1876     } else {
1877         // If no course is specified, then the user can see SITE + his courses.
1878         $courses1 = $DB->get_records('course', array('id' => SITEID));
1879         $courses2 = enrol_get_users_courses($userid, true, array('modinfo'));
1880         $courses = array_merge($courses1, $courses2);
1881     }
1882     if (!$courses) {
1883         return array();
1884     }
1886     $readableforums = array();
1888     foreach ($courses as $course) {
1890         $modinfo = get_fast_modinfo($course);
1892         if (empty($modinfo->instances['forum'])) {
1893             // hmm, no forums?
1894             continue;
1895         }
1897         $courseforums = $DB->get_records('forum', array('course' => $course->id));
1899         foreach ($modinfo->instances['forum'] as $forumid => $cm) {
1900             if (!$cm->uservisible or !isset($courseforums[$forumid])) {
1901                 continue;
1902             }
1903             $context = context_module::instance($cm->id);
1904             $forum = $courseforums[$forumid];
1905             $forum->context = $context;
1906             $forum->cm = $cm;
1908             if (!has_capability('mod/forum:viewdiscussion', $context)) {
1909                 continue;
1910             }
1912          /// group access
1913             if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
1915                 $forum->onlygroups = $modinfo->get_groups($cm->groupingid);
1916                 $forum->onlygroups[] = -1;
1917             }
1919         /// hidden timed discussions
1920             $forum->viewhiddentimedposts = true;
1921             if (!empty($CFG->forum_enabletimedposts)) {
1922                 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1923                     $forum->viewhiddentimedposts = false;
1924                 }
1925             }
1927         /// qanda access
1928             if ($forum->type == 'qanda'
1929                     && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
1931                 // We need to check whether the user has posted in the qanda forum.
1932                 $forum->onlydiscussions = array();  // Holds discussion ids for the discussions
1933                                                     // the user is allowed to see in this forum.
1934                 if ($discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $USER->id)) {
1935                     foreach ($discussionspostedin as $d) {
1936                         $forum->onlydiscussions[] = $d->id;
1937                     }
1938                 }
1939             }
1941             $readableforums[$forum->id] = $forum;
1942         }
1944         unset($modinfo);
1946     } // End foreach $courses
1948     return $readableforums;
1951 /**
1952  * Returns a list of posts found using an array of search terms.
1953  *
1954  * @global object
1955  * @global object
1956  * @global object
1957  * @param array $searchterms array of search terms, e.g. word +word -word
1958  * @param int $courseid if 0, we search through the whole site
1959  * @param int $limitfrom
1960  * @param int $limitnum
1961  * @param int &$totalcount
1962  * @param string $extrasql
1963  * @return array|bool Array of posts found or false
1964  */
1965 function forum_search_posts($searchterms, $courseid=0, $limitfrom=0, $limitnum=50,
1966                             &$totalcount, $extrasql='') {
1967     global $CFG, $DB, $USER;
1968     require_once($CFG->libdir.'/searchlib.php');
1970     $forums = forum_get_readable_forums($USER->id, $courseid);
1972     if (count($forums) == 0) {
1973         $totalcount = 0;
1974         return false;
1975     }
1977     $now = round(time(), -2); // db friendly
1979     $fullaccess = array();
1980     $where = array();
1981     $params = array();
1983     foreach ($forums as $forumid => $forum) {
1984         $select = array();
1986         if (!$forum->viewhiddentimedposts) {
1987             $select[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
1988             $params = array_merge($params, array('userid'.$forumid=>$USER->id, 'timestart'.$forumid=>$now, 'timeend'.$forumid=>$now));
1989         }
1991         $cm = $forum->cm;
1992         $context = $forum->context;
1994         if ($forum->type == 'qanda'
1995             && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
1996             if (!empty($forum->onlydiscussions)) {
1997                 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forum->onlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
1998                 $params = array_merge($params, $discussionid_params);
1999                 $select[] = "(d.id $discussionid_sql OR p.parent = 0)";
2000             } else {
2001                 $select[] = "p.parent = 0";
2002             }
2003         }
2005         if (!empty($forum->onlygroups)) {
2006             list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($forum->onlygroups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
2007             $params = array_merge($params, $groupid_params);
2008             $select[] = "d.groupid $groupid_sql";
2009         }
2011         if ($select) {
2012             $selects = implode(" AND ", $select);
2013             $where[] = "(d.forum = :forum{$forumid} AND $selects)";
2014             $params['forum'.$forumid] = $forumid;
2015         } else {
2016             $fullaccess[] = $forumid;
2017         }
2018     }
2020     if ($fullaccess) {
2021         list($fullid_sql, $fullid_params) = $DB->get_in_or_equal($fullaccess, SQL_PARAMS_NAMED, 'fula');
2022         $params = array_merge($params, $fullid_params);
2023         $where[] = "(d.forum $fullid_sql)";
2024     }
2026     $selectdiscussion = "(".implode(" OR ", $where).")";
2028     $messagesearch = '';
2029     $searchstring = '';
2031     // Need to concat these back together for parser to work.
2032     foreach($searchterms as $searchterm){
2033         if ($searchstring != '') {
2034             $searchstring .= ' ';
2035         }
2036         $searchstring .= $searchterm;
2037     }
2039     // We need to allow quoted strings for the search. The quotes *should* be stripped
2040     // by the parser, but this should be examined carefully for security implications.
2041     $searchstring = str_replace("\\\"","\"",$searchstring);
2042     $parser = new search_parser();
2043     $lexer = new search_lexer($parser);
2045     if ($lexer->parse($searchstring)) {
2046         $parsearray = $parser->get_parsed_array();
2047         list($messagesearch, $msparams) = search_generate_SQL($parsearray, 'p.message', 'p.subject',
2048                                                               'p.userid', 'u.id', 'u.firstname',
2049                                                               'u.lastname', 'p.modified', 'd.forum');
2050         $params = array_merge($params, $msparams);
2051     }
2053     $fromsql = "{forum_posts} p,
2054                   {forum_discussions} d,
2055                   {user} u";
2057     $selectsql = " $messagesearch
2058                AND p.discussion = d.id
2059                AND p.userid = u.id
2060                AND $selectdiscussion
2061                    $extrasql";
2063     $countsql = "SELECT COUNT(*)
2064                    FROM $fromsql
2065                   WHERE $selectsql";
2067     $allnames = get_all_user_name_fields(true, 'u');
2068     $searchsql = "SELECT p.*,
2069                          d.forum,
2070                          $allnames,
2071                          u.email,
2072                          u.picture,
2073                          u.imagealt
2074                     FROM $fromsql
2075                    WHERE $selectsql
2076                 ORDER BY p.modified DESC";
2078     $totalcount = $DB->count_records_sql($countsql, $params);
2080     return $DB->get_records_sql($searchsql, $params, $limitfrom, $limitnum);
2083 /**
2084  * Returns a list of all new posts that have not been mailed yet
2085  *
2086  * @param int $starttime posts created after this time
2087  * @param int $endtime posts created before this
2088  * @param int $now used for timed discussions only
2089  * @return array
2090  */
2091 function forum_get_unmailed_posts($starttime, $endtime, $now=null) {
2092     global $CFG, $DB;
2094     $params = array();
2095     $params['mailed'] = FORUM_MAILED_PENDING;
2096     $params['ptimestart'] = $starttime;
2097     $params['ptimeend'] = $endtime;
2098     $params['mailnow'] = 1;
2100     if (!empty($CFG->forum_enabletimedposts)) {
2101         if (empty($now)) {
2102             $now = time();
2103         }
2104         $timedsql = "AND (d.timestart < :dtimestart AND (d.timeend = 0 OR d.timeend > :dtimeend))";
2105         $params['dtimestart'] = $now;
2106         $params['dtimeend'] = $now;
2107     } else {
2108         $timedsql = "";
2109     }
2111     return $DB->get_records_sql("SELECT p.*, d.course, d.forum
2112                                  FROM {forum_posts} p
2113                                  JOIN {forum_discussions} d ON d.id = p.discussion
2114                                  WHERE p.mailed = :mailed
2115                                  AND p.created >= :ptimestart
2116                                  AND (p.created < :ptimeend OR p.mailnow = :mailnow)
2117                                  $timedsql
2118                                  ORDER BY p.modified ASC", $params);
2121 /**
2122  * Marks posts before a certain time as being mailed already
2123  *
2124  * @global object
2125  * @global object
2126  * @param int $endtime
2127  * @param int $now Defaults to time()
2128  * @return bool
2129  */
2130 function forum_mark_old_posts_as_mailed($endtime, $now=null) {
2131     global $CFG, $DB;
2133     if (empty($now)) {
2134         $now = time();
2135     }
2137     $params = array();
2138     $params['mailedsuccess'] = FORUM_MAILED_SUCCESS;
2139     $params['now'] = $now;
2140     $params['endtime'] = $endtime;
2141     $params['mailnow'] = 1;
2142     $params['mailedpending'] = FORUM_MAILED_PENDING;
2144     if (empty($CFG->forum_enabletimedposts)) {
2145         return $DB->execute("UPDATE {forum_posts}
2146                              SET mailed = :mailedsuccess
2147                              WHERE (created < :endtime OR mailnow = :mailnow)
2148                              AND mailed = :mailedpending", $params);
2149     } else {
2150         return $DB->execute("UPDATE {forum_posts}
2151                              SET mailed = :mailedsuccess
2152                              WHERE discussion NOT IN (SELECT d.id
2153                                                       FROM {forum_discussions} d
2154                                                       WHERE d.timestart > :now)
2155                              AND (created < :endtime OR mailnow = :mailnow)
2156                              AND mailed = :mailedpending", $params);
2157     }
2160 /**
2161  * Get all the posts for a user in a forum suitable for forum_print_post
2162  *
2163  * @global object
2164  * @global object
2165  * @uses CONTEXT_MODULE
2166  * @return array
2167  */
2168 function forum_get_user_posts($forumid, $userid) {
2169     global $CFG, $DB;
2171     $timedsql = "";
2172     $params = array($forumid, $userid);
2174     if (!empty($CFG->forum_enabletimedposts)) {
2175         $cm = get_coursemodule_from_instance('forum', $forumid);
2176         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2177             $now = time();
2178             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2179             $params[] = $now;
2180             $params[] = $now;
2181         }
2182     }
2184     $allnames = get_all_user_name_fields(true, 'u');
2185     return $DB->get_records_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
2186                               FROM {forum} f
2187                                    JOIN {forum_discussions} d ON d.forum = f.id
2188                                    JOIN {forum_posts} p       ON p.discussion = d.id
2189                                    JOIN {user} u              ON u.id = p.userid
2190                              WHERE f.id = ?
2191                                    AND p.userid = ?
2192                                    $timedsql
2193                           ORDER BY p.modified ASC", $params);
2196 /**
2197  * Get all the discussions user participated in
2198  *
2199  * @global object
2200  * @global object
2201  * @uses CONTEXT_MODULE
2202  * @param int $forumid
2203  * @param int $userid
2204  * @return array Array or false
2205  */
2206 function forum_get_user_involved_discussions($forumid, $userid) {
2207     global $CFG, $DB;
2209     $timedsql = "";
2210     $params = array($forumid, $userid);
2211     if (!empty($CFG->forum_enabletimedposts)) {
2212         $cm = get_coursemodule_from_instance('forum', $forumid);
2213         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2214             $now = time();
2215             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2216             $params[] = $now;
2217             $params[] = $now;
2218         }
2219     }
2221     return $DB->get_records_sql("SELECT DISTINCT d.*
2222                               FROM {forum} f
2223                                    JOIN {forum_discussions} d ON d.forum = f.id
2224                                    JOIN {forum_posts} p       ON p.discussion = d.id
2225                              WHERE f.id = ?
2226                                    AND p.userid = ?
2227                                    $timedsql", $params);
2230 /**
2231  * Get all the posts for a user in a forum suitable for forum_print_post
2232  *
2233  * @global object
2234  * @global object
2235  * @param int $forumid
2236  * @param int $userid
2237  * @return array of counts or false
2238  */
2239 function forum_count_user_posts($forumid, $userid) {
2240     global $CFG, $DB;
2242     $timedsql = "";
2243     $params = array($forumid, $userid);
2244     if (!empty($CFG->forum_enabletimedposts)) {
2245         $cm = get_coursemodule_from_instance('forum', $forumid);
2246         if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2247             $now = time();
2248             $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2249             $params[] = $now;
2250             $params[] = $now;
2251         }
2252     }
2254     return $DB->get_record_sql("SELECT COUNT(p.id) AS postcount, MAX(p.modified) AS lastpost
2255                              FROM {forum} f
2256                                   JOIN {forum_discussions} d ON d.forum = f.id
2257                                   JOIN {forum_posts} p       ON p.discussion = d.id
2258                                   JOIN {user} u              ON u.id = p.userid
2259                             WHERE f.id = ?
2260                                   AND p.userid = ?
2261                                   $timedsql", $params);
2264 /**
2265  * Given a log entry, return the forum post details for it.
2266  *
2267  * @global object
2268  * @global object
2269  * @param object $log
2270  * @return array|null
2271  */
2272 function forum_get_post_from_log($log) {
2273     global $CFG, $DB;
2275     $allnames = get_all_user_name_fields(true, 'u');
2276     if ($log->action == "add post") {
2278         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2279                                  FROM {forum_discussions} d,
2280                                       {forum_posts} p,
2281                                       {forum} f,
2282                                       {user} u
2283                                 WHERE p.id = ?
2284                                   AND d.id = p.discussion
2285                                   AND p.userid = u.id
2286                                   AND u.deleted <> '1'
2287                                   AND f.id = d.forum", array($log->info));
2290     } else if ($log->action == "add discussion") {
2292         return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2293                                  FROM {forum_discussions} d,
2294                                       {forum_posts} p,
2295                                       {forum} f,
2296                                       {user} u
2297                                 WHERE d.id = ?
2298                                   AND d.firstpost = p.id
2299                                   AND p.userid = u.id
2300                                   AND u.deleted <> '1'
2301                                   AND f.id = d.forum", array($log->info));
2302     }
2303     return NULL;
2306 /**
2307  * Given a discussion id, return the first post from the discussion
2308  *
2309  * @global object
2310  * @global object
2311  * @param int $dicsussionid
2312  * @return array
2313  */
2314 function forum_get_firstpost_from_discussion($discussionid) {
2315     global $CFG, $DB;
2317     return $DB->get_record_sql("SELECT p.*
2318                              FROM {forum_discussions} d,
2319                                   {forum_posts} p
2320                             WHERE d.id = ?
2321                               AND d.firstpost = p.id ", array($discussionid));
2324 /**
2325  * Returns an array of counts of replies to each discussion
2326  *
2327  * @global object
2328  * @global object
2329  * @param int $forumid
2330  * @param string $forumsort
2331  * @param int $limit
2332  * @param int $page
2333  * @param int $perpage
2334  * @return array
2335  */
2336 function forum_count_discussion_replies($forumid, $forumsort="", $limit=-1, $page=-1, $perpage=0) {
2337     global $CFG, $DB;
2339     if ($limit > 0) {
2340         $limitfrom = 0;
2341         $limitnum  = $limit;
2342     } else if ($page != -1) {
2343         $limitfrom = $page*$perpage;
2344         $limitnum  = $perpage;
2345     } else {
2346         $limitfrom = 0;
2347         $limitnum  = 0;
2348     }
2350     if ($forumsort == "") {
2351         $orderby = "";
2352         $groupby = "";
2354     } else {
2355         $orderby = "ORDER BY $forumsort";
2356         $groupby = ", ".strtolower($forumsort);
2357         $groupby = str_replace('desc', '', $groupby);
2358         $groupby = str_replace('asc', '', $groupby);
2359     }
2361     if (($limitfrom == 0 and $limitnum == 0) or $forumsort == "") {
2362         $sql = "SELECT p.discussion, COUNT(p.id) AS replies, MAX(p.id) AS lastpostid
2363                   FROM {forum_posts} p
2364                        JOIN {forum_discussions} d ON p.discussion = d.id
2365                  WHERE p.parent > 0 AND d.forum = ?
2366               GROUP BY p.discussion";
2367         return $DB->get_records_sql($sql, array($forumid));
2369     } else {
2370         $sql = "SELECT p.discussion, (COUNT(p.id) - 1) AS replies, MAX(p.id) AS lastpostid
2371                   FROM {forum_posts} p
2372                        JOIN {forum_discussions} d ON p.discussion = d.id
2373                  WHERE d.forum = ?
2374               GROUP BY p.discussion $groupby $orderby";
2375         return $DB->get_records_sql($sql, array($forumid), $limitfrom, $limitnum);
2376     }
2379 /**
2380  * @global object
2381  * @global object
2382  * @global object
2383  * @staticvar array $cache
2384  * @param object $forum
2385  * @param object $cm
2386  * @param object $course
2387  * @return mixed
2388  */
2389 function forum_count_discussions($forum, $cm, $course) {
2390     global $CFG, $DB, $USER;
2392     static $cache = array();
2394     $now = round(time(), -2); // db cache friendliness
2396     $params = array($course->id);
2398     if (!isset($cache[$course->id])) {
2399         if (!empty($CFG->forum_enabletimedposts)) {
2400             $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
2401             $params[] = $now;
2402             $params[] = $now;
2403         } else {
2404             $timedsql = "";
2405         }
2407         $sql = "SELECT f.id, COUNT(d.id) as dcount
2408                   FROM {forum} f
2409                        JOIN {forum_discussions} d ON d.forum = f.id
2410                  WHERE f.course = ?
2411                        $timedsql
2412               GROUP BY f.id";
2414         if ($counts = $DB->get_records_sql($sql, $params)) {
2415             foreach ($counts as $count) {
2416                 $counts[$count->id] = $count->dcount;
2417             }
2418             $cache[$course->id] = $counts;
2419         } else {
2420             $cache[$course->id] = array();
2421         }
2422     }
2424     if (empty($cache[$course->id][$forum->id])) {
2425         return 0;
2426     }
2428     $groupmode = groups_get_activity_groupmode($cm, $course);
2430     if ($groupmode != SEPARATEGROUPS) {
2431         return $cache[$course->id][$forum->id];
2432     }
2434     if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
2435         return $cache[$course->id][$forum->id];
2436     }
2438     require_once($CFG->dirroot.'/course/lib.php');
2440     $modinfo = get_fast_modinfo($course);
2442     $mygroups = $modinfo->get_groups($cm->groupingid);
2444     // add all groups posts
2445     $mygroups[-1] = -1;
2447     list($mygroups_sql, $params) = $DB->get_in_or_equal($mygroups);
2448     $params[] = $forum->id;
2450     if (!empty($CFG->forum_enabletimedposts)) {
2451         $timedsql = "AND d.timestart < $now AND (d.timeend = 0 OR d.timeend > $now)";
2452         $params[] = $now;
2453         $params[] = $now;
2454     } else {
2455         $timedsql = "";
2456     }
2458     $sql = "SELECT COUNT(d.id)
2459               FROM {forum_discussions} d
2460              WHERE d.groupid $mygroups_sql AND d.forum = ?
2461                    $timedsql";
2463     return $DB->get_field_sql($sql, $params);
2466 /**
2467  * Get all discussions in a forum
2468  *
2469  * @global object
2470  * @global object
2471  * @global object
2472  * @uses CONTEXT_MODULE
2473  * @uses VISIBLEGROUPS
2474  * @param object $cm
2475  * @param string $forumsort
2476  * @param bool $fullpost
2477  * @param int $unused
2478  * @param int $limit
2479  * @param bool $userlastmodified
2480  * @param int $page
2481  * @param int $perpage
2482  * @param int $groupid if groups enabled, get discussions for this group overriding the current group.
2483  *                     Use FORUM_POSTS_ALL_USER_GROUPS for all the user groups
2484  * @return array
2485  */
2486 function forum_get_discussions($cm, $forumsort="", $fullpost=true, $unused=-1, $limit=-1,
2487                                 $userlastmodified=false, $page=-1, $perpage=0, $groupid = -1) {
2488     global $CFG, $DB, $USER;
2490     $timelimit = '';
2492     $now = round(time(), -2);
2493     $params = array($cm->instance);
2495     $modcontext = context_module::instance($cm->id);
2497     if (!has_capability('mod/forum:viewdiscussion', $modcontext)) { /// User must have perms to view discussions
2498         return array();
2499     }
2501     if (!empty($CFG->forum_enabletimedposts)) { /// Users must fulfill timed posts
2503         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2504             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2505             $params[] = $now;
2506             $params[] = $now;
2507             if (isloggedin()) {
2508                 $timelimit .= " OR d.userid = ?";
2509                 $params[] = $USER->id;
2510             }
2511             $timelimit .= ")";
2512         }
2513     }
2515     if ($limit > 0) {
2516         $limitfrom = 0;
2517         $limitnum  = $limit;
2518     } else if ($page != -1) {
2519         $limitfrom = $page*$perpage;
2520         $limitnum  = $perpage;
2521     } else {
2522         $limitfrom = 0;
2523         $limitnum  = 0;
2524     }
2526     $groupmode    = groups_get_activity_groupmode($cm);
2528     if ($groupmode) {
2530         if (empty($modcontext)) {
2531             $modcontext = context_module::instance($cm->id);
2532         }
2534         // Special case, we received a groupid to override currentgroup.
2535         if ($groupid > 0) {
2536             $course = get_course($cm->course);
2537             if (!groups_group_visible($groupid, $course, $cm)) {
2538                 // User doesn't belong to this group, return nothing.
2539                 return array();
2540             }
2541             $currentgroup = $groupid;
2542         } else if ($groupid === -1) {
2543             $currentgroup = groups_get_activity_group($cm);
2544         } else {
2545             // Get discussions for all groups current user can see.
2546             $currentgroup = null;
2547         }
2549         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2550             if ($currentgroup) {
2551                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2552                 $params[] = $currentgroup;
2553             } else {
2554                 $groupselect = "";
2555             }
2557         } else {
2558             // Separate groups.
2560             // Get discussions for all groups current user can see.
2561             if ($currentgroup === null) {
2562                 $mygroups = array_keys(groups_get_all_groups($cm->course, $USER->id, $cm->groupingid, 'g.id'));
2563                 if (empty($mygroups)) {
2564                      $groupselect = "AND d.groupid = -1";
2565                 } else {
2566                     list($insqlgroups, $inparamsgroups) = $DB->get_in_or_equal($mygroups);
2567                     $groupselect = "AND (d.groupid = -1 OR d.groupid $insqlgroups)";
2568                     $params = array_merge($params, $inparamsgroups);
2569                 }
2570             } else if ($currentgroup) {
2571                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2572                 $params[] = $currentgroup;
2573             } else {
2574                 $groupselect = "AND d.groupid = -1";
2575             }
2576         }
2577     } else {
2578         $groupselect = "";
2579     }
2580     if (empty($forumsort)) {
2581         $forumsort = forum_get_default_sort_order();
2582     }
2583     if (empty($fullpost)) {
2584         $postdata = "p.id,p.subject,p.modified,p.discussion,p.userid";
2585     } else {
2586         $postdata = "p.*";
2587     }
2589     if (empty($userlastmodified)) {  // We don't need to know this
2590         $umfields = "";
2591         $umtable  = "";
2592     } else {
2593         $umfields = ', ' . get_all_user_name_fields(true, 'um', null, 'um') . ', um.email AS umemail, um.picture AS umpicture,
2594                         um.imagealt AS umimagealt';
2595         $umtable  = " LEFT JOIN {user} um ON (d.usermodified = um.id)";
2596     }
2598     $allnames = get_all_user_name_fields(true, 'u');
2599     $sql = "SELECT $postdata, d.name, d.timemodified, d.usermodified, d.groupid, d.timestart, d.timeend, d.pinned, $allnames,
2600                    u.email, u.picture, u.imagealt $umfields
2601               FROM {forum_discussions} d
2602                    JOIN {forum_posts} p ON p.discussion = d.id
2603                    JOIN {user} u ON p.userid = u.id
2604                    $umtable
2605              WHERE d.forum = ? AND p.parent = 0
2606                    $timelimit $groupselect
2607           ORDER BY $forumsort, d.id DESC";
2608     return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
2611 /**
2612  * Gets the neighbours (previous and next) of a discussion.
2613  *
2614  * The calculation is based on the timemodified when time modified or time created is identical
2615  * It will revert to using the ID to sort consistently. This is better tha skipping a discussion.
2616  *
2617  * For blog-style forums, the calculation is based on the original creation time of the
2618  * blog post.
2619  *
2620  * Please note that this does not check whether or not the discussion passed is accessible
2621  * by the user, it simply uses it as a reference to find the neighbours. On the other hand,
2622  * the returned neighbours are checked and are accessible to the current user.
2623  *
2624  * @param object $cm The CM record.
2625  * @param object $discussion The discussion record.
2626  * @param object $forum The forum instance record.
2627  * @return array That always contains the keys 'prev' and 'next'. When there is a result
2628  *               they contain the record with minimal information such as 'id' and 'name'.
2629  *               When the neighbour is not found the value is false.
2630  */
2631 function forum_get_discussion_neighbours($cm, $discussion, $forum) {
2632     global $CFG, $DB, $USER;
2634     if ($cm->instance != $discussion->forum or $discussion->forum != $forum->id or $forum->id != $cm->instance) {
2635         throw new coding_exception('Discussion is not part of the same forum.');
2636     }
2638     $neighbours = array('prev' => false, 'next' => false);
2639     $now = round(time(), -2);
2640     $params = array();
2642     $modcontext = context_module::instance($cm->id);
2643     $groupmode    = groups_get_activity_groupmode($cm);
2644     $currentgroup = groups_get_activity_group($cm);
2646     // Users must fulfill timed posts.
2647     $timelimit = '';
2648     if (!empty($CFG->forum_enabletimedposts)) {
2649         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2650             $timelimit = ' AND ((d.timestart <= :tltimestart AND (d.timeend = 0 OR d.timeend > :tltimeend))';
2651             $params['tltimestart'] = $now;
2652             $params['tltimeend'] = $now;
2653             if (isloggedin()) {
2654                 $timelimit .= ' OR d.userid = :tluserid';
2655                 $params['tluserid'] = $USER->id;
2656             }
2657             $timelimit .= ')';
2658         }
2659     }
2661     // Limiting to posts accessible according to groups.
2662     $groupselect = '';
2663     if ($groupmode) {
2664         if ($groupmode == VISIBLEGROUPS || has_capability('moodle/site:accessallgroups', $modcontext)) {
2665             if ($currentgroup) {
2666                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2667                 $params['groupid'] = $currentgroup;
2668             }
2669         } else {
2670             if ($currentgroup) {
2671                 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2672                 $params['groupid'] = $currentgroup;
2673             } else {
2674                 $groupselect = 'AND d.groupid = -1';
2675             }
2676         }
2677     }
2679     $params['forumid'] = $cm->instance;
2680     $params['discid1'] = $discussion->id;
2681     $params['discid2'] = $discussion->id;
2682     $params['discid3'] = $discussion->id;
2683     $params['discid4'] = $discussion->id;
2684     $params['disctimecompare1'] = $discussion->timemodified;
2685     $params['disctimecompare2'] = $discussion->timemodified;
2686     $params['pinnedstate1'] = (int) $discussion->pinned;
2687     $params['pinnedstate2'] = (int) $discussion->pinned;
2688     $params['pinnedstate3'] = (int) $discussion->pinned;
2689     $params['pinnedstate4'] = (int) $discussion->pinned;
2691     $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
2692               FROM {forum_discussions} d
2693               JOIN {forum_posts} p ON d.firstpost = p.id
2694              WHERE d.forum = :forumid
2695                AND d.id <> :discid1
2696                    $timelimit
2697                    $groupselect";
2698     $comparefield = "d.timemodified";
2699     $comparevalue = ":disctimecompare1";
2700     $comparevalue2  = ":disctimecompare2";
2701     if (!empty($CFG->forum_enabletimedposts)) {
2702         // Here we need to take into account the release time (timestart)
2703         // if one is set, of the neighbouring posts and compare it to the
2704         // timestart or timemodified of *this* post depending on if the
2705         // release date of this post is in the future or not.
2706         // This stops discussions that appear later because of the
2707         // timestart value from being buried under discussions that were
2708         // made afterwards.
2709         $comparefield = "CASE WHEN d.timemodified < d.timestart
2710                                 THEN d.timestart ELSE d.timemodified END";
2711         if ($discussion->timemodified < $discussion->timestart) {
2712             // Normally we would just use the timemodified for sorting
2713             // discussion posts. However, when timed discussions are enabled,
2714             // then posts need to be sorted base on the later of timemodified
2715             // or the release date of the post (timestart).
2716             $params['disctimecompare1'] = $discussion->timestart;
2717             $params['disctimecompare2'] = $discussion->timestart;
2718         }
2719     }
2720     $orderbydesc = forum_get_default_sort_order(true, $comparefield, 'd', false);
2721     $orderbyasc = forum_get_default_sort_order(false, $comparefield, 'd', false);
2723     if ($forum->type === 'blog') {
2724          $subselect = "SELECT pp.created
2725                    FROM {forum_discussions} dd
2726                    JOIN {forum_posts} pp ON dd.firstpost = pp.id ";
2728          $subselectwhere1 = " WHERE dd.id = :discid3";
2729          $subselectwhere2 = " WHERE dd.id = :discid4";
2731          $comparefield = "p.created";
2733          $sub1 = $subselect.$subselectwhere1;
2734          $comparevalue = "($sub1)";
2736          $sub2 = $subselect.$subselectwhere2;
2737          $comparevalue2 = "($sub2)";
2739          $orderbydesc = "d.pinned, p.created DESC";
2740          $orderbyasc = "d.pinned, p.created ASC";
2741     }
2743     $prevsql = $sql . " AND ( (($comparefield < $comparevalue) AND :pinnedstate1 = d.pinned)
2744                          OR ($comparefield = $comparevalue2 AND (d.pinned = 0 OR d.pinned = :pinnedstate4) AND d.id < :discid2)
2745                          OR (d.pinned = 0 AND d.pinned <> :pinnedstate2))
2746                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbydesc, d.id DESC";
2748     $nextsql = $sql . " AND ( (($comparefield > $comparevalue) AND :pinnedstate1 = d.pinned)
2749                          OR ($comparefield = $comparevalue2 AND (d.pinned = 1 OR d.pinned = :pinnedstate4) AND d.id > :discid2)
2750                          OR (d.pinned = 1 AND d.pinned <> :pinnedstate2))
2751                    ORDER BY CASE WHEN d.pinned = :pinnedstate3 THEN 1 ELSE 0 END DESC, $orderbyasc, d.id ASC";
2753     $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
2754     $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
2755     return $neighbours;
2758 /**
2759  * Get the sql to use in the ORDER BY clause for forum discussions.
2760  *
2761  * This has the ordering take timed discussion windows into account.
2762  *
2763  * @param bool $desc True for DESC, False for ASC.
2764  * @param string $compare The field in the SQL to compare to normally sort by.
2765  * @param string $prefix The prefix being used for the discussion table.
2766  * @param bool $pinned sort pinned posts to the top
2767  * @return string
2768  */
2769 function forum_get_default_sort_order($desc = true, $compare = 'd.timemodified', $prefix = 'd', $pinned = true) {
2770     global $CFG;
2772     if (!empty($prefix)) {
2773         $prefix .= '.';
2774     }
2776     $dir = $desc ? 'DESC' : 'ASC';
2778     if ($pinned == true) {
2779         $pinned = "{$prefix}pinned DESC,";
2780     } else {
2781         $pinned = '';
2782     }
2784     $sort = "{$prefix}timemodified";
2785     if (!empty($CFG->forum_enabletimedposts)) {
2786         $sort = "CASE WHEN {$compare} < {$prefix}timestart
2787                  THEN {$prefix}timestart
2788                  ELSE {$compare}
2789                  END";
2790     }
2791     return "$pinned $sort $dir";
2794 /**
2795  *
2796  * @global object
2797  * @global object
2798  * @global object
2799  * @uses CONTEXT_MODULE
2800  * @uses VISIBLEGROUPS
2801  * @param object $cm
2802  * @return array
2803  */
2804 function forum_get_discussions_unread($cm) {
2805     global $CFG, $DB, $USER;
2807     $now = round(time(), -2);
2808     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2810     $params = array();
2811     $groupmode    = groups_get_activity_groupmode($cm);
2812     $currentgroup = groups_get_activity_group($cm);
2814     if ($groupmode) {
2815         $modcontext = context_module::instance($cm->id);
2817         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2818             if ($currentgroup) {
2819                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2820                 $params['currentgroup'] = $currentgroup;
2821             } else {
2822                 $groupselect = "";
2823             }
2825         } else {
2826             //separate groups without access all
2827             if ($currentgroup) {
2828                 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2829                 $params['currentgroup'] = $currentgroup;
2830             } else {
2831                 $groupselect = "AND d.groupid = -1";
2832             }
2833         }
2834     } else {
2835         $groupselect = "";
2836     }
2838     if (!empty($CFG->forum_enabletimedposts)) {
2839         $timedsql = "AND d.timestart < :now1 AND (d.timeend = 0 OR d.timeend > :now2)";
2840         $params['now1'] = $now;
2841         $params['now2'] = $now;
2842     } else {
2843         $timedsql = "";
2844     }
2846     $sql = "SELECT d.id, COUNT(p.id) AS unread
2847               FROM {forum_discussions} d
2848                    JOIN {forum_posts} p     ON p.discussion = d.id
2849                    LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = $USER->id)
2850              WHERE d.forum = {$cm->instance}
2851                    AND p.modified >= :cutoffdate AND r.id is NULL
2852                    $groupselect
2853                    $timedsql
2854           GROUP BY d.id";
2855     $params['cutoffdate'] = $cutoffdate;
2857     if ($unreads = $DB->get_records_sql($sql, $params)) {
2858         foreach ($unreads as $unread) {
2859             $unreads[$unread->id] = $unread->unread;
2860         }
2861         return $unreads;
2862     } else {
2863         return array();
2864     }
2867 /**
2868  * @global object
2869  * @global object
2870  * @global object
2871  * @uses CONEXT_MODULE
2872  * @uses VISIBLEGROUPS
2873  * @param object $cm
2874  * @return array
2875  */
2876 function forum_get_discussions_count($cm) {
2877     global $CFG, $DB, $USER;
2879     $now = round(time(), -2);
2880     $params = array($cm->instance);
2881     $groupmode    = groups_get_activity_groupmode($cm);
2882     $currentgroup = groups_get_activity_group($cm);
2884     if ($groupmode) {
2885         $modcontext = context_module::instance($cm->id);
2887         if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2888             if ($currentgroup) {
2889                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2890                 $params[] = $currentgroup;
2891             } else {
2892                 $groupselect = "";
2893             }
2895         } else {
2896             //seprate groups without access all
2897             if ($currentgroup) {
2898                 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2899                 $params[] = $currentgroup;
2900             } else {
2901                 $groupselect = "AND d.groupid = -1";
2902             }
2903         }
2904     } else {
2905         $groupselect = "";
2906     }
2908     $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2910     $timelimit = "";
2912     if (!empty($CFG->forum_enabletimedposts)) {
2914         $modcontext = context_module::instance($cm->id);
2916         if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2917             $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2918             $params[] = $now;
2919             $params[] = $now;
2920             if (isloggedin()) {
2921                 $timelimit .= " OR d.userid = ?";
2922                 $params[] = $USER->id;
2923             }
2924             $timelimit .= ")";
2925         }
2926     }
2928     $sql = "SELECT COUNT(d.id)
2929               FROM {forum_discussions} d
2930                    JOIN {forum_posts} p ON p.discussion = d.id
2931              WHERE d.forum = ? AND p.parent = 0
2932                    $groupselect $timelimit";
2934     return $DB->get_field_sql($sql, $params);
2938 // OTHER FUNCTIONS ///////////////////////////////////////////////////////////
2941 /**
2942  * @global object
2943  * @global object
2944  * @param int $courseid
2945  * @param string $type
2946  */
2947 function forum_get_course_forum($courseid, $type) {
2948 // How to set up special 1-per-course forums
2949     global $CFG, $DB, $OUTPUT, $USER;
2951     if ($forums = $DB->get_records_select("forum", "course = ? AND type = ?", array($courseid, $type), "id ASC")) {
2952         // There should always only be ONE, but with the right combination of
2953         // errors there might be more.  In this case, just return the oldest one (lowest ID).
2954         foreach ($forums as $forum) {
2955             return $forum;   // ie the first one
2956         }
2957     }
2959     // Doesn't exist, so create one now.
2960     $forum = new stdClass();
2961     $forum->course = $courseid;
2962     $forum->type = "$type";
2963     if (!empty($USER->htmleditor)) {
2964         $forum->introformat = $USER->htmleditor;
2965     }
2966     switch ($forum->type) {
2967         case "news":
2968             $forum->name  = get_string("namenews", "forum");
2969             $forum->intro = get_string("intronews", "forum");
2970             $forum->forcesubscribe = FORUM_FORCESUBSCRIBE;
2971             $forum->assessed = 0;
2972             if ($courseid == SITEID) {
2973                 $forum->name  = get_string("sitenews");
2974                 $forum->forcesubscribe = 0;
2975             }
2976             break;
2977         case "social":
2978             $forum->name  = get_string("namesocial", "forum");
2979             $forum->intro = get_string("introsocial", "forum");
2980             $forum->assessed = 0;
2981             $forum->forcesubscribe = 0;
2982             break;
2983         case "blog":
2984             $forum->name = get_string('blogforum', 'forum');
2985             $forum->intro = get_string('introblog', 'forum');
2986             $forum->assessed = 0;
2987             $forum->forcesubscribe = 0;
2988             break;
2989         default:
2990             echo $OUTPUT->notification("That forum type doesn't exist!");
2991             return false;
2992             break;
2993     }
2995     $forum->timemodified = time();
2996     $forum->id = $DB->insert_record("forum", $forum);
2998     if (! $module = $DB->get_record("modules", array("name" => "forum"))) {
2999         echo $OUTPUT->notification("Could not find forum module!!");
3000         return false;
3001     }
3002     $mod = new stdClass();
3003     $mod->course = $courseid;
3004     $mod->module = $module->id;
3005     $mod->instance = $forum->id;
3006     $mod->section = 0;
3007     include_once("$CFG->dirroot/course/lib.php");
3008     if (! $mod->coursemodule = add_course_module($mod) ) {
3009         echo $OUTPUT->notification("Could not add a new course module to the course '" . $courseid . "'");
3010         return false;
3011     }
3012     $sectionid = course_add_cm_to_section($courseid, $mod->coursemodule, 0);
3013     return $DB->get_record("forum", array("id" => "$forum->id"));
3016 /**
3017  * Print a forum post
3018  *
3019  * @global object
3020  * @global object
3021  * @uses FORUM_MODE_THREADED
3022  * @uses PORTFOLIO_FORMAT_PLAINHTML
3023  * @uses PORTFOLIO_FORMAT_FILE
3024  * @uses PORTFOLIO_FORMAT_RICHHTML
3025  * @uses PORTFOLIO_ADD_TEXT_LINK
3026  * @uses CONTEXT_MODULE
3027  * @param object $post The post to print.
3028  * @param object $discussion
3029  * @param object $forum
3030  * @param object $cm
3031  * @param object $course
3032  * @param boolean $ownpost Whether this post belongs to the current user.
3033  * @param boolean $reply Whether to print a 'reply' link at the bottom of the message.
3034  * @param boolean $link Just print a shortened version of the post as a link to the full post.
3035  * @param string $footer Extra stuff to print after the message.
3036  * @param string $highlight Space-separated list of terms to highlight.
3037  * @param int $post_read true, false or -99. If we already know whether this user
3038  *          has read this post, pass that in, otherwise, pass in -99, and this
3039  *          function will work it out.
3040  * @param boolean $dummyifcantsee When forum_user_can_see_post says that
3041  *          the current user can't see this post, if this argument is true
3042  *          (the default) then print a dummy 'you can't see this post' post.
3043  *          If false, don't output anything at all.
3044  * @param bool|null $istracked
3045  * @return void
3046  */
3047 function forum_print_post($post, $discussion, $forum, &$cm, $course, $ownpost=false, $reply=false, $link=false,
3048                           $footer="", $highlight="", $postisread=null, $dummyifcantsee=true, $istracked=null, $return=false) {
3049     global $USER, $CFG, $OUTPUT;
3051     require_once($CFG->libdir . '/filelib.php');
3053     // String cache
3054     static $str;
3056     $modcontext = context_module::instance($cm->id);
3058     $post->course = $course->id;
3059     $post->forum  = $forum->id;
3060     $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
3061     if (!empty($CFG->enableplagiarism)) {
3062         require_once($CFG->libdir.'/plagiarismlib.php');
3063         $post->message .= plagiarism_get_links(array('userid' => $post->userid,
3064             'content' => $post->message,
3065             'cmid' => $cm->id,
3066             'course' => $post->course,
3067             'forum' => $post->forum));
3068     }
3070     // caching
3071     if (!isset($cm->cache)) {
3072         $cm->cache = new stdClass;
3073     }
3075     if (!isset($cm->cache->caps)) {
3076         $cm->cache->caps = array();
3077         $cm->cache->caps['mod/forum:viewdiscussion']   = has_capability('mod/forum:viewdiscussion', $modcontext);
3078         $cm->cache->caps['moodle/site:viewfullnames']  = has_capability('moodle/site:viewfullnames', $modcontext);
3079         $cm->cache->caps['mod/forum:editanypost']      = has_capability('mod/forum:editanypost', $modcontext);
3080         $cm->cache->caps['mod/forum:splitdiscussions'] = has_capability('mod/forum:splitdiscussions', $modcontext);
3081         $cm->cache->caps['mod/forum:deleteownpost']    = has_capability('mod/forum:deleteownpost', $modcontext);
3082         $cm->cache->caps['mod/forum:deleteanypost']    = has_capability('mod/forum:deleteanypost', $modcontext);
3083         $cm->cache->caps['mod/forum:viewanyrating']    = has_capability('mod/forum:viewanyrating', $modcontext);
3084         $cm->cache->caps['mod/forum:exportpost']       = has_capability('mod/forum:exportpost', $modcontext);
3085         $cm->cache->caps['mod/forum:exportownpost']    = has_capability('mod/forum:exportownpost', $modcontext);
3086     }
3088     if (!isset($cm->uservisible)) {
3089         $cm->uservisible = \core_availability\info_module::is_user_visible($cm, 0, false);
3090     }
3092     if ($istracked && is_null($postisread)) {
3093         $postisread = forum_tp_is_post_read($USER->id, $post);
3094     }
3096     if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
3097         $output = '';
3098         if (!$dummyifcantsee) {
3099             if ($return) {
3100                 return $output;
3101             }
3102             echo $output;
3103             return;
3104         }
3105         $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3106         $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix',
3107                                                        'role' => 'region',
3108                                                        'aria-label' => get_string('hiddenforumpost', 'forum')));
3109         $output .= html_writer::start_tag('div', array('class'=>'row header'));
3110         $output .= html_writer::tag('div', '', array('class'=>'left picture')); // Picture
3111         if ($post->parent) {
3112             $output .= html_writer::start_tag('div', array('class'=>'topic'));
3113         } else {
3114             $output .= html_writer::start_tag('div', array('class'=>'topic starter'));
3115         }
3116         $output .= html_writer::tag('div', get_string('forumsubjecthidden','forum'), array('class' => 'subject',
3117                                                                                            'role' => 'header')); // Subject.
3118         $output .= html_writer::tag('div', get_string('forumauthorhidden', 'forum'), array('class' => 'author',
3119                                                                                            'role' => 'header')); // Author.
3120         $output .= html_writer::end_tag('div');
3121         $output .= html_writer::end_tag('div'); // row
3122         $output .= html_writer::start_tag('div', array('class'=>'row'));
3123         $output .= html_writer::tag('div', '&nbsp;', array('class'=>'left side')); // Groups
3124         $output .= html_writer::tag('div', get_string('forumbodyhidden','forum'), array('class'=>'content')); // Content
3125         $output .= html_writer::end_tag('div'); // row
3126         $output .= html_writer::end_tag('div'); // forumpost
3128         if ($return) {
3129             return $output;
3130         }
3131         echo $output;
3132         return;
3133     }
3135     if (empty($str)) {
3136         $str = new stdClass;
3137         $str->edit         = get_string('edit', 'forum');
3138         $str->delete       = get_string('delete', 'forum');
3139         $str->reply        = get_string('reply', 'forum');
3140         $str->parent       = get_string('parent', 'forum');
3141         $str->pruneheading = get_string('pruneheading', 'forum');
3142         $str->prune        = get_string('prune', 'forum');
3143         $str->displaymode     = get_user_preferences('forum_displaymode', $CFG->forum_displaymode);
3144         $str->markread     = get_string('markread', 'forum');
3145         $str->markunread   = get_string('markunread', 'forum');
3146     }
3148     $discussionlink = new moodle_url('/mod/forum/discuss.php', array('d'=>$post->discussion));
3150     // Build an object that represents the posting user
3151     $postuser = new stdClass;
3152     $postuserfields = explode(',', user_picture::fields());
3153     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
3154     $postuser->id = $post->userid;
3155     $postuser->fullname    = fullname($postuser, $cm->cache->caps['moodle/site:viewfullnames']);
3156     $postuser->profilelink = new moodle_url('/user/view.php', array('id'=>$post->userid, 'course'=>$course->id));
3158     // Prepare the groups the posting user belongs to
3159     if (isset($cm->cache->usersgroups)) {
3160         $groups = array();
3161         if (isset($cm->cache->usersgroups[$post->userid])) {
3162             foreach ($cm->cache->usersgroups[$post->userid] as $gid) {
3163                 $groups[$gid] = $cm->cache->groups[$gid];
3164             }
3165         }
3166     } else {
3167         $groups = groups_get_all_groups($course->id, $post->userid, $cm->groupingid);
3168     }
3170     // Prepare the attachements for the post, files then images
3171     list($attachments, $attachedimages) = forum_print_attachments($post, $cm, 'separateimages');
3173     // Determine if we need to shorten this post
3174     $shortenpost = ($link && (strlen(strip_tags($post->message)) > $CFG->forum_longpost));
3177     // Prepare an array of commands
3178     $commands = array();
3180     // SPECIAL CASE: The front page can display a news item post to non-logged in users.
3181     // Don't display the mark read / unread controls in this case.
3182     if ($istracked && $CFG->forum_usermarksread && isloggedin()) {
3183         $url = new moodle_url($discussionlink, array('postid'=>$post->id, 'mark'=>'unread'));
3184         $text = $str->markunread;
3185         if (!$postisread) {
3186             $url->param('mark', 'read');
3187             $text = $str->markread;
3188         }
3189         if ($str->displaymode == FORUM_MODE_THREADED) {
3190             $url->param('parent', $post->parent);
3191         } else {
3192             $url->set_anchor('p'.$post->id);
3193         }
3194         $commands[] = array('url'=>$url, 'text'=>$text);
3195     }
3197     // Zoom in to the parent specifically
3198     if ($post->parent) {
3199         $url = new moodle_url($discussionlink);
3200         if ($str->displaymode == FORUM_MODE_THREADED) {
3201             $url->param('parent', $post->parent);
3202         } else {
3203             $url->set_anchor('p'.$post->parent);
3204         }
3205         $commands[] = array('url'=>$url, 'text'=>$str->parent);
3206     }
3208     // Hack for allow to edit news posts those are not displayed yet until they are displayed
3209     $age = time() - $post->created;
3210     if (!$post->parent && $forum->type == 'news' && $discussion->timestart > time()) {
3211         $age = 0;
3212     }
3214     if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3215         if (has_capability('moodle/course:manageactivities', $modcontext)) {
3216             // The first post in single simple is the forum description.
3217             $commands[] = array('url'=>new moodle_url('/course/modedit.php', array('update'=>$cm->id, 'sesskey'=>sesskey(), 'return'=>1)), 'text'=>$str->edit);
3218         }
3219     } else if (($ownpost && $age < $CFG->maxeditingtime) || $cm->cache->caps['mod/forum:editanypost']) {
3220         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('edit'=>$post->id)), 'text'=>$str->edit);
3221     }
3223     if ($cm->cache->caps['mod/forum:splitdiscussions'] && $post->parent && $forum->type != 'single') {
3224         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('prune'=>$post->id)), 'text'=>$str->prune, 'title'=>$str->pruneheading);
3225     }
3227     if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3228         // Do not allow deleting of first post in single simple type.
3229     } else if (($ownpost && $age < $CFG->maxeditingtime && $cm->cache->caps['mod/forum:deleteownpost']) || $cm->cache->caps['mod/forum:deleteanypost']) {
3230         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('delete'=>$post->id)), 'text'=>$str->delete);
3231     }
3233     if ($reply) {
3234         $commands[] = array('url'=>new moodle_url('/mod/forum/post.php#mformforum', array('reply'=>$post->id)), 'text'=>$str->reply);
3235     }
3237     if ($CFG->enableportfolios && ($cm->cache->caps['mod/forum:exportpost'] || ($ownpost && $cm->cache->caps['mod/forum:exportownpost']))) {
3238         $p = array('postid' => $post->id);
3239         require_once($CFG->libdir.'/portfoliolib.php');
3240         $button = new portfolio_add_button();
3241         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id), 'mod_forum');
3242         if (empty($attachments)) {
3243             $button->set_formats(PORTFOLIO_FORMAT_PLAINHTML);
3244         } else {
3245             $button->set_formats(PORTFOLIO_FORMAT_RICHHTML);
3246         }
3248         $porfoliohtml = $button->to_html(PORTFOLIO_ADD_TEXT_LINK);
3249         if (!empty($porfoliohtml)) {
3250             $commands[] = $porfoliohtml;
3251         }
3252     }
3253     // Finished building commands
3256     // Begin output
3258     $output  = '';
3260     if ($istracked) {
3261         if ($postisread) {
3262             $forumpostclass = ' read';
3263         } else {
3264             $forumpostclass = ' unread';
3265             $output .= html_writer::tag('a', '', array('name'=>'unread'));
3266         }
3267     } else {
3268         // ignore trackign status if not tracked or tracked param missing
3269         $forumpostclass = '';
3270     }
3272     $topicclass = '';
3273     if (empty($post->parent)) {
3274         $topicclass = ' firstpost starter';
3275     }
3277     if (!empty($post->lastpost)) {
3278         $forumpostclass .= ' lastpost';
3279     }
3281     $postbyuser = new stdClass;
3282     $postbyuser->post = $post->subject;
3283     $postbyuser->user = $postuser->fullname;
3284     $discussionbyuser = get_string('postbyuser', 'forum', $postbyuser);
3285     $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3286     $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix'.$forumpostclass.$topicclass,
3287                                                    'role' => 'region',
3288                                                    'aria-label' => $discussionbyuser));
3289     $output .= html_writer::start_tag('div', array('class'=>'row header clearfix'));
3290     $output .= html_writer::start_tag('div', array('class'=>'left picture'));
3291     $output .= $OUTPUT->user_picture($postuser, array('courseid'=>$course->id));
3292     $output .= html_writer::end_tag('div');
3295     $output .= html_writer::start_tag('div', array('class'=>'topic'.$topicclass));
3297     $postsubject = $post->subject;
3298     if (empty($post->subjectnoformat)) {
3299         $postsubject = format_string($postsubject);
3300     }
3301     $output .= html_writer::tag('div', $postsubject, array('class'=>'subject',
3302                                                            'role' => 'heading',
3303                                                            'aria-level' => '2'));
3305     $by = new stdClass();
3306     $by->name = html_writer::link($postuser->profilelink, $postuser->fullname);
3307     $by->date = userdate($post->modified);
3308     $output .= html_writer::tag('div', get_string('bynameondate', 'forum', $by), array('class'=>'author',
3309                                                                                        'role' => 'heading',
3310                                                                                        'aria-level' => '2'));
3312     $output .= html_writer::end_tag('div'); //topic
3313     $output .= html_writer::end_tag('div'); //row
3315     $output .= html_writer::start_tag('div', array('class'=>'row maincontent clearfix'));
3316     $output .= html_writer::start_tag('div', array('class'=>'left'));
3318     $groupoutput = '';
3319     if ($groups) {
3320         $groupoutput = print_group_picture($groups, $course->id, false, true, true);
3321     }
3322     if (empty($groupoutput)) {
3323         $groupoutput = '&nbsp;';
3324     }
3325     $output .= html_writer::tag('div', $groupoutput, array('class'=>'grouppictures'));
3327     $output .= html_writer::end_tag('div'); //left side
3328     $output .= html_writer::start_tag('div', array('class'=>'no-overflow'));
3329     $output .= html_writer::start_tag('div', array('class'=>'content'));
3331     $options = new stdClass;
3332     $options->para    = false;
3333     $options->trusted = $post->messagetrust;
3334     $options->context = $modcontext;
3335     if ($shortenpost) {
3336         // Prepare shortened version by filtering the text then shortening it.
3337         $postclass    = 'shortenedpost';
3338         $postcontent  = format_text($post->message, $post->messageformat, $options);
3339         $postcontent  = shorten_text($postcontent, $CFG->forum_shortpost);
3340         $postcontent .= html_writer::link($discussionlink, get_string('readtherest', 'forum'));
3341         $postcontent .= html_writer::tag('div', '('.get_string('numwords', 'moodle', count_words($post->message)).')',
3342             array('class'=>'post-word-count'));
3343     } else {
3344         // Prepare whole post
3345         $postclass    = 'fullpost';
3346         $postcontent  = format_text($post->message, $post->messageformat, $options, $course->id);
3347         if (!empty($highlight)) {
3348             $postcontent = highlight($highlight, $postcontent);
3349         }
3350         if (!empty($forum->displaywordcount)) {
3351             $postcontent .= html_writer::tag('div', get_string('numwords', 'moodle', count_words($post->message)),
3352                 array('class'=>'post-word-count'));
3353         }
3354         $postcontent .= html_writer::tag('div', $attachedimages, array('class'=>'attachedimages'));
3355     }
3357     // Output the post content
3358     $output .= html_writer::tag('div', $postcontent, array('class'=>'posting '.$postclass));
3359     $output .= html_writer::end_tag('div'); // Content
3360     $output .= html_writer::end_tag('div'); // Content mask
3361     $output .= html_writer::end_tag('div'); // Row
3363     $output .= html_writer::start_tag('div', array('class'=>'row side'));
3364     $output .= html_writer::tag('div','&nbsp;', array('class'=>'left'));
3365     $output .= html_writer::start_tag('div', array('class'=>'options clearfix'));
3367     if (!empty($attachments)) {
3368         $output .= html_writer::tag('div', $attachments, array('class' => 'attachments'));
3369     }
3371     // Output ratings
3372     if (!empty($post->rating)) {
3373         $output .= html_writer::tag('div', $OUTPUT->render($post->rating), array('class'=>'forum-post-rating'));
3374     }
3376     // Output the commands
3377     $commandhtml = array();
3378     foreach ($commands as $command) {
3379         if (is_array($command)) {
3380             $commandhtml[] = html_writer::link($command['url'], $command['text']);
3381         } else {
3382             $commandhtml[] = $command;
3383         }
3384     }
3385     $output .= html_writer::tag('div', implode(' | ', $commandhtml), array('class'=>'commands'));
3387     // Output link to post if required
3388     if ($link && forum_user_can_post($forum, $discussion, $USER, $cm, $course, $modcontext)) {
3389         if ($post->replies == 1) {
3390             $replystring = get_string('repliesone', 'forum', $post->replies);
3391         } else {
3392             $replystring = get_string('repliesmany', 'forum', $post->replies);
3393         }
3394         if (!empty($discussion->unread) && $discussion->unread !== '-') {
3395             $replystring .= ' <span class="sep">/</span> <span class="unread">';
3396             if ($discussion->unread == 1) {
3397                 $replystring .= get_string('unreadpostsone', 'forum');
3398             } else {
3399                 $replystring .= get_string('unreadpostsnumber', 'forum', $discussion->unread);
3400             }
3401             $replystring .= '</span>';
3402         }
3404         $output .= html_writer::start_tag('div', array('class'=>'link'));
3405         $output .= html_writer::link($discussionlink, get_string('discussthistopic', 'forum'));
3406         $output .= '&nbsp;('.$replystring.')';
3407         $output .= html_writer::end_tag('div'); // link
3408     }
3410     // Output footer if required
3411     if ($footer) {
3412         $output .= html_writer::tag('div', $footer, array('class'=>'footer'));
3413     }
3415     // Close remaining open divs
3416     $output .= html_writer::end_tag('div'); // content
3417     $output .= html_writer::end_tag('div'); // row
3418     $output .= html_writer::end_tag('div'); // forumpost
3420     // Mark the forum post as read if required
3421     if ($istracked && !$CFG->forum_usermarksread && !$postisread) {
3422         forum_tp_mark_post_read($USER->id, $post, $forum->id);
3423     }
3425     if ($return) {
3426         return $output;
3427     }
3428     echo $output;
3429     return;
3432 /**
3433  * Return rating related permissions
3434  *
3435  * @param string $options the context id
3436  * @return array an associative array of the user's rating permissions
3437  */
3438 function forum_rating_permissions($contextid, $component, $ratingarea) {
3439     $context = context::instance_by_id($contextid, MUST_EXIST);
3440     if ($component != 'mod_forum' || $ratingarea != 'post') {
3441         // We don't know about this component/ratingarea so just return null to get the
3442         // default restrictive permissions.
3443         return null;
3444     }
3445     return array(
3446         'view'    => has_capability('mod/forum:viewrating', $context),
3447         'viewany' => has_capability('mod/forum:viewanyrating', $context),
3448         'viewall' => has_capability('mod/forum:viewallratings', $context),
3449         'rate'    => has_capability('mod/forum:rate', $context)
3450     );
3453 /**
3454  * Validates a submitted rating
3455  * @param array $params submitted data
3456  *            context => object the context in which the rated items exists [required]
3457  *            component => The component for this module - should always be mod_forum [required]
3458  *            ratingarea => object the context in which the rated items exists [required]
3459  *            itemid => int the ID of the object being rated [required]
3460  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
3461  *            rating => int the submitted rating [required]
3462  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
3463  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
3464  * @return boolean true if the rating is valid. Will throw rating_exception if not
3465  */
3466 function forum_rating_validate($params) {
3467     global $DB, $USER;
3469     // Check the component is mod_forum
3470     if ($params['component'] != 'mod_forum') {
3471         throw new rating_exception('invalidcomponent');
3472     }
3474     // Check the ratingarea is post (the only rating area in forum)
3475     if ($params['ratingarea'] != 'post') {
3476         throw new rating_exception('invalidratingarea');
3477     }
3479     // Check the rateduserid is not the current user .. you can't rate your own posts
3480     if ($params['rateduserid'] == $USER->id) {
3481         throw new rating_exception('nopermissiontorate');
3482     }
3484     // Fetch all the related records ... we need to do this anyway to call forum_user_can_see_post
3485     $post = $DB->get_record('forum_posts', array('id' => $params['itemid'], 'userid' => $params['rateduserid']), '*', MUST_EXIST);
3486     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion), '*', MUST_EXIST);
3487     $forum = $DB->get_record('forum', array('id' => $discussion->forum), '*', MUST_EXIST);
3488     $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
3489     $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id , false, MUST_EXIST);
3490     $context = context_module::instance($cm->id);
3492     // Make sure the context provided is the context of the forum
3493     if ($context->id != $params['context']->id) {
3494         throw new rating_exception('invalidcontext');
3495     }
3497     if ($forum->scale != $params['scaleid']) {
3498         //the scale being submitted doesnt match the one in the database
3499         throw new rating_exception('invalidscaleid');
3500     }
3502     // check the item we're rating was created in the assessable time window
3503     if (!empty($forum->assesstimestart) && !empty($forum->assesstimefinish)) {
3504         if ($post->created < $forum->assesstimestart || $post->created > $forum->assesstimefinish) {
3505             throw new rating_exception('notavailable');
3506         }
3507     }
3509     //check that the submitted rating is valid for the scale
3511     // lower limit
3512     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
3513         throw new rating_exception('invalidnum');
3514     }
3516     // upper limit
3517     if ($forum->scale < 0) {
3518         //its a custom scale
3519         $scalerecord = $DB->get_record('scale', array('id' => -$forum->scale));
3520         if ($scalerecord) {
3521             $scalearray = explode(',', $scalerecord->scale);
3522             if ($params['rating'] > count($scalearray)) {
3523                 throw new rating_exception('invalidnum');
3524             }
3525         } else {
3526             throw new rating_exception('invalidscaleid');
3527         }
3528     } else if ($params['rating'] > $forum->scale) {
3529         //if its numeric and submitted rating is above maximum
3530         throw new rating_exception('invalidnum');
3531     }
3533     // Make sure groups allow this user to see the item they're rating
3534     if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
3535         if (!groups_group_exists($discussion->groupid)) { // Can't find group
3536             throw new rating_exception('cannotfindgroup');//something is wrong
3537         }
3539         if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
3540             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
3541             throw new rating_exception('notmemberofgroup');
3542         }
3543     }
3545     // perform some final capability checks
3546     if (!forum_user_can_see_post($forum, $discussion, $post, $USER, $cm)) {
3547         throw new rating_exception('nopermissiontorate');
3548     }
3550     return true;
3553 /**
3554  * Can the current user see ratings for a given itemid?
3555  *
3556  * @param array $params submitted data
3557  *            contextid => int contextid [required]
3558  *            component => The component for this module - should always be mod_forum [required]
3559  *            ratingarea => object the context in which the rated items exists [required]
3560  *            itemid => int the ID of the object being rated [required]
3561  *            scaleid => int scale id [optional]
3562  * @return bool
3563  * @throws coding_exception
3564  * @throws rating_exception
3565  */
3566 function mod_forum_rating_can_see_item_ratings($params) {
3567     global $DB, $USER;
3569     // Check the component is mod_forum.
3570     if (!isset($params['component']) || $params['component'] != 'mod_forum') {
3571         throw new rating_exception('invalidcomponent');
3572     }
3574     // Check the ratingarea is post (the only rating area in forum).
3575     if (!isset($params['ratingarea']) || $params['ratingarea'] != 'post') {
3576         throw new rating_exception('invalidratingarea');
3577     }
3579     if (!isset($params['itemid'])) {
3580         throw new rating_exception('invaliditemid');
3581     }
3583     $post = $DB->get_record('forum_posts', array('id' => $params['itemid']), '*', MUST_EXIST);
3584     $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion), '*', MUST_EXIST);
3585     $forum = $DB->get_record('forum', array('id' => $discussion->forum), '*', MUST_EXIST);
3586     $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
3587     $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id , false, MUST_EXIST);
3589     // Perform some final capability checks.
3590     if (!forum_user_can_see_post($forum, $discussion, $post, $USER, $cm)) {
3591         return false;
3592     }
3593     return true;
3596 /**
3597  * This function prints the overview of a discussion in the forum listing.
3598  * It needs some discussion information and some post information, these
3599  * happen to be combined for efficiency in the $post parameter by the function
3600  * that calls this one: forum_print_latest_discussions()
3601  *
3602  * @global object
3603  * @global object
3604  * @param object $post The post object (passed by reference for speed).
3605  * @param object $forum The forum object.
3606  * @param int $group Current group.
3607  * @param string $datestring Format to use for the dates.
3608  * @param boolean $cantrack Is tracking enabled for this forum.
3609  * @param boolean $forumtracked Is the user tracking this forum.
3610  * @param boolean $canviewparticipants True if user has the viewparticipants permission for this course
3611  * @param boolean $canviewhiddentimedposts True if user has the viewhiddentimedposts permission for this forum
3612  */
3613 function forum_print_discussion_header(&$post, $forum, $group = -1, $datestring = "",
3614                                         $cantrack = true, $forumtracked = true, $canviewparticipants = true, $modcontext = null,
3615                                         $canviewhiddentimedposts = false) {
3617     global $COURSE, $USER, $CFG, $OUTPUT, $PAGE;
3619     static $rowcount;
3620     static $strmarkalldread;
3622     if (empty($modcontext)) {
3623         if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
3624             print_error('invalidcoursemodule');
3625         }
3626         $modcontext = context_module::instance($cm->id);
3627     }
3629     if (!isset($rowcount)) {
3630         $rowcount = 0;
3631         $strmarkalldread = get_string('markalldread', 'forum');
3632     } else {
3633         $rowcount = ($rowcount + 1) % 2;
3634     }
3636     $post->subject = format_string($post->subject,true);
3638     $timeddiscussion = !empty($CFG->forum_enabletimedposts) && ($post->timestart || $post->timeend);
3639     $timedoutsidewindow = '';
3640     if ($timeddiscussion && ($post->timestart > time() || ($post->timeend != 0 && $post->timeend < time()))) {
3641         $timedoutsidewindow = ' dimmed_text';
3642     }
3644     echo "\n\n";
3645     echo '<tr class="discussion r'.$rowcount.$timedoutsidewindow.'">';
3647     $topicclass = 'topic starter';
3648     if (FORUM_DISCUSSION_PINNED == $post->pinned) {
3649         $topicclass .= ' pinned';
3650     }
3651     echo '<td class="'.$topicclass.'">';
3652     if (FORUM_DISCUSSION_PINNED == $post->pinned) {
3653         echo $OUTPUT->pix_icon('i/pinned', get_string('discussionpinned', 'forum'), 'mod_forum');
3654     }
3655     $canalwaysseetimedpost = $USER->id == $post->userid || $canviewhiddentimedposts;
3656     if ($timeddiscussion && $canalwaysseetimedpost) {
3657         echo $PAGE->get_renderer('mod_forum')->timed_discussion_tooltip($post, empty($timedoutsidewindow));
3658     }
3660     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">'.$post->subject.'</a>';
3661     echo "</td>\n";
3663     // Picture
3664     $postuser = new stdClass();
3665     $postuserfields = explode(',', user_picture::fields());
3666     $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
3667     $postuser->id = $post->userid;
3668     echo '<td class="picture">';
3669     echo $OUTPUT->user_picture($postuser, array('courseid'=>$forum->course));
3670     echo "</td>\n";
3672     // User name
3673     $fullname = fullname($postuser, has_capability('moodle/site:viewfullnames', $modcontext));
3674     echo '<td class="author">';
3675     echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->userid.'&amp;course='.$forum->course.'">'.$fullname.'</a>';
3676     echo "</td>\n";
3678     // Group picture
3679     if ($group !== -1) {  // Groups are active - group is a group data object or NULL
3680         echo '<td class="picture group">';
3681         if (!empty($group->picture) and empty($group->hidepicture)) {
3682             if ($canviewparticipants && $COURSE->groupmode) {
3683                 $picturelink = true;
3684             } else {
3685                 $picturelink = false;
3686             }
3687             print_group_picture($group, $forum->course, false, false, $picturelink);
3688         } else if (isset($group->id)) {
3689             if ($canviewparticipants && $COURSE->groupmode) {
3690                 echo '<a href="'.$CFG->wwwroot.'/user/index.php?id='.$forum->course.'&amp;group='.$group->id.'">'.$group->name.'</a>';
3691             } else {
3692                 echo $group->name;
3693             }
3694         }
3695         echo "</td>\n";
3696     }
3698     if (has_capability('mod/forum:viewdiscussion', $modcontext)) {   // Show the column with replies
3699         echo '<td class="replies">';
3700         echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
3701         echo $post->replies.'</a>';
3702         echo "</td>\n";
3704         if ($cantrack) {
3705             echo '<td class="replies">';
3706             if ($forumtracked) {
3707                 if ($post->unread > 0) {
3708                     echo '<span class="unread">';
3709                     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'#unread">';
3710                     echo $post->unread;
3711                     echo '</a>';
3712                     echo '<a title="'.$strmarkalldread.'" href="'.$CFG->wwwroot.'/mod/forum/markposts.php?f='.
3713                          $forum->id.'&amp;d='.$post->discussion.'&amp;mark=read&amp;returnpage=view.php">' .
3714                          '<img src="'.$OUTPUT->pix_url('t/markasread') . '" class="iconsmall" alt="'.$strmarkalldread.'" /></a>';
3715                     echo '</span>';
3716                 } else {
3717                     echo '<span class="read">';
3718                     echo $post->unread;
3719                     echo '</span>';
3720                 }
3721             } else {
3722                 echo '<span class="read">';
3723                 echo '-';
3724                 echo '</span>';
3725             }
3726             echo "</td>\n";
3727         }
3728     }
3730     echo '<td class="lastpost">';
3731     $usedate = (empty($post->timemodified)) ? $post->modified : $post->timemodified;  // Just in case
3732     $parenturl = '';
3733     $usermodified = new stdClass();
3734     $usermodified->id = $post->usermodified;
3735     $usermodified = username_load_fields_from_object($usermodified, $post, 'um');
3737     // In QA forums we check that the user can view participants.
3738     if ($forum->type !== 'qanda' || $canviewparticipants) {
3739         echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->usermodified.'&amp;course='.$forum->course.'">'.
3740              fullname($usermodified).'</a><br />';
3741         $parenturl = (empty($post->lastpostid)) ? '' : '&amp;parent='.$post->lastpostid;
3742     }
3744     echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.$parenturl.'">'.
3745           userdate($usedate, $datestring).'</a>';
3746     echo "</td>\n";
3748     // is_guest should be used here as this also checks whether the user is a guest in the current course.
3749     // Guests and visitors cannot subscribe - only enrolled users.
3750     if ((!is_guest($modcontext, $USER) && isloggedin()) && has_capability('mod/forum:viewdiscussion', $modcontext)) {
3751         // Discussion subscription.
3752         if (\mod_forum\subscriptions::is_subscribable($forum)) {
3753             echo '<td class="discussionsubscription">';
3754             echo forum_get_discussion_subscription_icon($forum, $post->discussion);
3755             echo '</td>';
3756         }
3757     }
3759     echo "</tr>\n\n";
3763 /**
3764  * Return the markup for the discussion subscription toggling icon.
3765  *
3766  * @param stdClass $forum The forum object.
3767  * @param int $discussionid The discussion to create an icon for.
3768  * @return string The generated markup.
3769  */
3770 function forum_get_discussion_subscription_icon($forum, $discussionid, $returnurl = null, $includetext = false) {
3771     global $USER, $OUTPUT, $PAGE;
3773     if ($returnurl === null && $PAGE->url) {
3774         $returnurl = $PAGE->url->out();
3775     }
3777     $o = '';
3778     $subscriptionstatus = \mod_forum\subscriptions::is_subscribed($USER->id, $forum, $discussionid);
3779     $subscriptionlink = new moodle_url('/mod/forum/subscribe.php', array(
3780         'sesskey' => sesskey(),
3781         'id' => $forum->id,
3782         'd' => $discussionid,
3783         'returnurl' => $returnurl,
3784     ));
3786     if ($includetext) {
3787         $o .= $subscriptionstatus ? get_string('subscribed', 'mod_forum') : get_string('notsubscribed', 'mod_forum');
3788     }
3790     if ($subscriptionstatus) {
3791         $output = $OUTPUT->pix_icon('t/subscribed', get_string('clicktounsubscribe', 'forum'), 'mod_forum');
3792         if ($includetext) {
3793             $output .= get_string('subscribed', 'mod_forum');
3794         }
3796         return html_writer::link($subscriptionlink, $output, array(
3797                 'title' => get_string('clicktounsubscribe', 'forum'),
3798                 'class' => 'discussiontoggle iconsmall',
3799                 'data-forumid' => $forum->id,
3800                 'data-discussionid' => $discussionid,
3801                 'data-includetext' => $includetext,
3802             ));
3804     } else {
3805         $output = $OUTPUT->pix_icon('t/unsubscribed', get_string('clicktosubscribe', 'forum'), 'mod_forum');
3806         if ($includetext) {
3807             $output .= get_string('notsubscribed', 'mod_forum');
3808         }
3810         return html_writer::link($subscriptionlink, $output, array(
3811                 'title' => get_string('clicktosubscribe', 'forum'),
3812                 'class' => 'discussiontoggle iconsmall',
3813                 'data-forumid' => $forum->id,
3814                 'data-discussionid' => $discussionid,
3815                 'data-includetext' => $includetext,
3816             ));
3817     }
3820 /**
3821  * Return a pair of spans containing classes to allow the subscribe and
3822  * unsubscribe icons to be pre-loaded by a browser.
3823  *
3824  * @return string The generated markup
3825  */
3826 function forum_get_discussion_subscription_icon_preloaders() {
3827     $o = '';
3828     $o .= html_writer::span('&nbsp;', 'preload-subscribe');
3829     $o .= html_writer::span('&nbsp;', 'preload-unsubscribe');
3830     return $o;
3833 /**
3834  * Print the drop down that allows the user to select how they want to have
3835  * the discussion displayed.
3836  *
3837  * @param int $id forum id if $forumtype is 'single',
3838  *              discussion id for any other forum type
3839  * @param mixed $mode forum layout mode
3840  * @param string $forumtype optional
3841  */
3842 function forum_print_mode_form($id, $mode, $forumtype='') {
3843     global $OUTPUT;
3844     if ($forumtype == 'single') {
3845         $select = new single_select(new moodle_url("/mod/forum/view.php", array('f'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
3846         $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
3847         $select->class = "forummode";
3848     } else {
3849         $select = new single_select(new moodle_url("/mod/forum/discuss.php", array('d'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
3850         $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
3851     }
3852     echo $OUTPUT->render($select);
3855 /**
3856  * @global object
3857  * @param object $course
3858  * @param string $search
3859  * @return string
3860  */
3861 function forum_search_form($course, $search='') {
3862     global $CFG, $OUTPUT;
3864     $output  = '<div class="forumsearch">';
3865     $output .= '<form action="'.$CFG->wwwroot.'/mod/forum/search.php" style="display:inline">';
3866     $output .= '<fieldset class="invisiblefieldset">';
3867     $output .= $OUTPUT->help_icon('search');
3868     $output .= '<label class="accesshide" for="search" >'.get_string('search', 'forum').'</label>';
3869     $output .= '<input id="search" name="search" type="text" size="18" value="'.s($search, true).'" />';
3870     $output .= '<label class="accesshide" for="searchforums" >'.get_string('searchforums', 'forum').'</label>';
3871     $output .= '<input id="searchforums" value="'.get_string('searchforums', 'forum').'" type="submit" />';
3872     $output .= '<input name="id" type="hidden" value="'.$course->id.'" />';
3873     $output .= '</fieldset>';
3874     $output .= '</form>';
3875     $output .= '</div>';
3877     return $output;
3881 /**
3882  * @global object
3883  * @global object
3884  */
3885 function forum_set_return() {
3886     global $CFG, $SESSION;
3888     if (! isset($SESSION->fromdiscussion)) {
3889         $referer = get_local_referer(false);
3890         // If the referer is NOT a login screen then save it.
3891         if (! strncasecmp("$CFG->wwwroot/login", $referer, 300)) {
3892             $SESSION->fromdiscussion = $referer;
3893         }
3894     }
3898 /**
3899  * @global object
3900  * @param string|\moodle_url $default
3901  * @return string
3902  */
3903 function forum_go_back_to($default) {
3904     global $SESSION;
3906     if (!empty($SESSION->fromdiscussion)) {
3907         $returnto = $SESSION->fromdiscussion;
3908         unset($SESSION->fromdiscussion);
3909         return $returnto;
3910     } else {
3911         return $default;
3912     }
3915 /**
3916  * Given a discussion object that is being moved to $forumto,
3917  * this function checks all posts in that discussion
3918  * for attachments, and if any are found, these are
3919  * moved to the new forum directory.
3920  *
3921  * @global object
3922  * @param object $discussion
3923  * @param int $forumfrom source forum id
3924  * @param int $forumto target forum id
3925  * @return bool success
3926  */
3927 function forum_move_attachments($discussion, $forumfrom, $forumto) {
3928     global $DB;
3930     $fs = get_file_storage();
3932     $newcm = get_coursemodule_from_instance('forum', $forumto);
3933     $oldcm = get_coursemodule_from_instance('forum', $forumfrom);
3935     $newcontext = context_module::instance($newcm->id);
3936     $oldcontext = context_module::instance($oldcm->id);
3938     // loop through all posts, better not use attachment flag ;-)
3939     if ($posts = $DB->get_records('forum_posts', array('discussion'=>$discussion->id), '', 'id, attachment')) {
3940         foreach ($posts as $post) {
3941             $fs->move_area_files_to_new_context($oldcontext->id,
3942                     $newcontext->id, 'mod_forum', 'post', $post->id);
3943             $attachmentsmoved = $fs->move_area_files_to_new_context($oldcontext->id,
3944                     $newcontext->id, 'mod_forum', 'attachment', $post->id);
3945             if ($attachmentsmoved > 0 && $post->attachment != '1') {
3946                 // Weird - let's fix it
3947                 $post->attachment = '1';
3948                 $DB->update_record('forum_posts', $post);
3949             } else if ($attachmentsmoved == 0 && $post->attachment != '') {
3950                 // Weird - let's fix it
3951                 $post->attachment = '';
3952                 $DB->update_record('forum_posts', $post);
3953             }
3954         }
3955     }
3957     return true;
3960 /**
3961  * Returns attachments as formated text/html optionally with separate images
3962  *
3963  * @global object
3964  * @global object
3965  * @global object
3966  * @param object $post
3967  * @param object $cm
3968  * @param string $type html/text/separateimages
3969  * @return mixed string or array of (html text withouth images and image HTML)
3970  */
3971 function forum_print_attachments($post, $cm, $type) {
3972     global $CFG, $DB, $USER, $OUTPUT;
3974     if (empty($post->attachment)) {
3975         return $type !== 'separateimages' ? '' : array('', '');
3976     }
3978     if (!in_array($type, array('separateimages', 'html', 'text'))) {
3979         return $type !== 'separateimages' ? '' : array('', '');
3980     }
3982     if (!$context = context_module::instance($cm->id)) {
3983         return $type !== 'separateimages' ? '' : array('', '');
3984     }
3985     $strattachment = get_string('attachment', 'forum');
3987     $fs = get_file_storage();
3989     $imagereturn = '';
3990     $output = '';
3992     $canexport = !empty($CFG->enableportfolios) && (has_capability('mod/forum:exportpost', $context) || ($post->userid == $USER->id && has_capability('mod/forum:exportownpost', $context)));
3994     if ($canexport) {
3995         require_once($CFG->libdir.'/portfoliolib.php');
3996     }
3998     // We retrieve all files according to the time that they were created.  In the case that several files were uploaded
3999     // at the sametime (e.g. in the case of drag/drop upload) we revert to using the filename.
4000     $files = $fs->get_area_files($context->id, 'mod_forum', 'attachment', $post->id, "filename", false);
4001     if ($files) {
4002         if ($canexport) {
4003             $button = new portfolio_add_button();
4004         }
4005         foreach ($files as $file) {
4006             $filename = $file->get_filename();
4007             $mimetype = $file->get_mimetype();
4008             $iconimage = $OUTPUT->pix_icon(file_file_icon($file), get_mimetype_description($file), 'moodle', array('class' => 'icon'));
4009             $path = file_encode_url($CFG->wwwroot.'/pluginfile.php', '/'.$context->id.'/mod_forum/attachment/'.$post->id.'/'.$filename);
4011             if ($type == 'html') {
4012                 $output .= "<a href=\"$path\">$iconimage</a> ";
4013                 $output .= "<a href=\"$path\">".s($filename)."</a>";
4014                 if ($canexport) {
4015                     $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
4016                     $button->set_format_by_file($file);
4017                     $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
4018                 }
4019                 $output .= "<br />";
4021             } else if ($type == 'text') {
4022                 $output .= "$strattachment ".s($filename).":\n$path\n";
4024             } else { //'returnimages'
4025                 if (in_array($mimetype, array('image/gif', 'image/jpeg', 'image/png'))) {
4026                     // Image attachments don't get printed as links
4027                     $imagereturn .= "<br /><img src=\"$path\" alt=\"\" />";
4028                     if ($canexport) {
4029                         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
4030                         $button->set_format_by_file($file);
4031                         $imagereturn .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
4032                     }
4033                 } else {
4034                     $output .= "<a href=\"$path\">$iconimage</a> ";
4035                     $output .= format_text("<a href=\"$path\">".s($filename)."</a>", FORMAT_HTML, array('context'=>$context));
4036                     if ($canexport) {
4037                         $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
4038                         $button->set_format_by_file($file);
4039                         $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
4040                     }
4041                     $output .= '<br />';
4042                 }
4043             }