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