?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MDL-48309 mod_forum: Do not escape ampersands in plain text email
[moodle.git] / mod / forum / lib.php
blobe81994a555629444c7ec6b817562e502e8a75214
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/>.
16
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 */
22
23 defined('MOODLE_INTERNAL') || die();
24
25 /** Include required files */
26 require_once(__DIR__ . '/deprecatedlib.php');
27 require_once($CFG->libdir.'/filelib.php');
28 require_once($CFG->libdir.'/eventslib.php');
29
30 /// CONSTANTS ///////////////////////////////////////////////////////////
31
32 define('FORUM_MODE_FLATOLDEST', 1);
33 define('FORUM_MODE_FLATNEWEST', -1);
34 define('FORUM_MODE_THREADED', 2);
35 define('FORUM_MODE_NESTED', 3);
36
37 define('FORUM_CHOOSESUBSCRIBE', 0);
38 define('FORUM_FORCESUBSCRIBE', 1);
39 define('FORUM_INITIALSUBSCRIBE', 2);
40 define('FORUM_DISALLOWSUBSCRIBE',3);
41
42 /**
43 * FORUM_TRACKING_OFF - Tracking is not available for this forum.
44 */
45 define('FORUM_TRACKING_OFF', 0);
46
47 /**
48 * FORUM_TRACKING_OPTIONAL - Tracking is based on user preference.
49 */
50 define('FORUM_TRACKING_OPTIONAL', 1);
51
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);
57
58 define('FORUM_MAILED_PENDING', 0);
59 define('FORUM_MAILED_SUCCESS', 1);
60 define('FORUM_MAILED_ERROR', 2);
61
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 }
66
67 /// STANDARD FUNCTIONS ///////////////////////////////////////////////////////////
68
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;
81
82 $forum->timemodified = time();
83
84 if (empty($forum->assessed)) {
85 $forum->assessed = 0;
86 }
87
88 if (empty($forum->ratingtime) or empty($forum->assessed)) {
89 $forum->assesstimestart = 0;
90 $forum->assesstimefinish = 0;
91 }
92
93 $forum->id = $DB->insert_record('forum', $forum);
94 $modcontext = context_module::instance($forum->coursemodule);
95
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;
107
108 $message = '';
109
110 $discussion->id = forum_add_discussion($discussion, null, $message);
111
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);
116
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 }
122
123 forum_grade_item_update($forum);
124
125 return $forum->id;
126 }
127
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 }
143 }
144
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;
156
157 $forum->timemodified = time();
158 $forum->id = $forum->instance;
159
160 if (empty($forum->assessed)) {
161 $forum->assessed = 0;
162 }
163
164 if (empty($forum->ratingtime) or empty($forum->assessed)) {
165 $forum->assesstimestart = 0;
166 $forum->assesstimefinish = 0;
167 }
168
169 $oldforum = $DB->get_record('forum', array('id'=>$forum->id));
170
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 }
177
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;
197
198 $message = '';
199
200 forum_add_discussion($discussion, null, $message);
201
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 }
209
210 $cm = get_coursemodule_from_instance('forum', $forum->id);
211 $modcontext = context_module::instance($cm->id, MUST_EXIST);
212
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.
220
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 }
226
227 $DB->update_record('forum_posts', $post);
228 $discussion->name = $forum->name;
229 $DB->update_record('forum_discussions', $discussion);
230 }
231
232 $DB->update_record('forum', $forum);
233
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 }
241
242 forum_grade_item_update($forum);
243
244 return true;
245 }
246
247
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;
259
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 }
269
270 $context = context_module::instance($cm->id);
271
272 // now get rid of all files
273 $fs = get_file_storage();
274 $fs->delete_area_files($context->id);
275
276 $result = true;
277
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));
282
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 }
290
291 forum_tp_delete_read_records(-1, -1, -1, $forum->id);
292
293 if (!$DB->delete_records('forum', array('id'=>$forum->id))) {
294 $result = false;
295 }
296
297 forum_grade_item_delete($forum);
298
299 return $result;
300 }
301
302
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;
329
330 default: return null;
331 }
332 }
333
334
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;
350
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 }
355
356 $result=$type; // Default return value
357
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";
367
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 }
394
395 return $result;
396 }
397
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.'>';
410 }
411
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) {
419
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.
423
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);
432 }
433
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;
447
448 $site = get_site();
449
450 // All users that are subscribed to any post that needs sending,
451 // please increase $CFG->extramemorylimit on large sites that
452 // send notifications to a large number of users.
453 $users = array();
454 $userscount = 0; // Cached user counter - count($users) in PHP is horribly slow!!!
455
456 // Status arrays.
457 $mailcount = array();
458 $errorcount = array();
459
460 // caches
461 $discussions = array();
462 $forums = array();
463 $courses = array();
464 $coursemodules = array();
465 $subscribedusers = array();
466 $messageinboundhandlers = array();
467
468 // Posts older than 2 days will not be mailed. This is to avoid the problem where
469 // cron has not been running for a long time, and then suddenly people are flooded
470 // with mail from the past few weeks or months
471 $timenow = time();
472 $endtime = $timenow - $CFG->maxeditingtime;
473 $starttime = $endtime - 48 * 3600; // Two days earlier
474
475 // Get the list of forum subscriptions for per-user per-forum maildigest settings.
476 $digestsset = $DB->get_recordset('forum_digests', null, '', 'id, userid, forum, maildigest');
477 $digests = array();
478 foreach ($digestsset as $thisrow) {
479 if (!isset($digests[$thisrow->forum])) {
480 $digests[$thisrow->forum] = array();
481 }
482 $digests[$thisrow->forum][$thisrow->userid] = $thisrow->maildigest;
483 }
484 $digestsset->close();
485
486 // Create the generic messageinboundgenerator.
487 $messageinboundgenerator = new \core\message\inbound\address_manager();
488 $messageinboundgenerator->set_handler('\mod_forum\message\inbound\reply_handler');
489
490 if ($posts = forum_get_unmailed_posts($starttime, $endtime, $timenow)) {
491 // Mark them all now as being mailed. It's unlikely but possible there
492 // might be an error later so that a post is NOT actually mailed out,
493 // but since mail isn't crucial, we can accept this risk. Doing it now
494 // prevents the risk of duplicated mails, which is a worse problem.
495
496 if (!forum_mark_old_posts_as_mailed($endtime)) {
497 mtrace('Errors occurred while trying to mark some posts as being mailed.');
498 return false; // Don't continue trying to mail them, in case we are in a cron loop
499 }
500
501 // checking post validity, and adding users to loop through later
502 foreach ($posts as $pid => $post) {
503
504 $discussionid = $post->discussion;
505 if (!isset($discussions[$discussionid])) {
506 if ($discussion = $DB->get_record('forum_discussions', array('id'=> $post->discussion))) {
507 $discussions[$discussionid] = $discussion;
508 \mod_forum\subscriptions::fill_subscription_cache($discussion->forum);
509 \mod_forum\subscriptions::fill_discussion_subscription_cache($discussion->forum);
510
511 } else {
512 mtrace('Could not find discussion ' . $discussionid);
513 unset($posts[$pid]);
514 continue;
515 }
516 }
517 $forumid = $discussions[$discussionid]->forum;
518 if (!isset($forums[$forumid])) {
519 if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
520 $forums[$forumid] = $forum;
521 } else {
522 mtrace('Could not find forum '.$forumid);
523 unset($posts[$pid]);
524 continue;
525 }
526 }
527 $courseid = $forums[$forumid]->course;
528 if (!isset($courses[$courseid])) {
529 if ($course = $DB->get_record('course', array('id' => $courseid))) {
530 $courses[$courseid] = $course;
531 } else {
532 mtrace('Could not find course '.$courseid);
533 unset($posts[$pid]);
534 continue;
535 }
536 }
537 if (!isset($coursemodules[$forumid])) {
538 if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
539 $coursemodules[$forumid] = $cm;
540 } else {
541 mtrace('Could not find course module for forum '.$forumid);
542 unset($posts[$pid]);
543 continue;
544 }
545 }
546
547 // Save the Inbound Message datakey here to reduce DB queries later.
548 $messageinboundgenerator->set_data($pid);
549 $messageinboundhandlers[$pid] = $messageinboundgenerator->fetch_data_key();
550
551 // Caching subscribed users of each forum.
552 if (!isset($subscribedusers[$forumid])) {
553 $modcontext = context_module::instance($coursemodules[$forumid]->id);
554 if ($subusers = \mod_forum\subscriptions::fetch_subscribed_users($forums[$forumid], 0, $modcontext, 'u.*', true)) {
555
556 foreach ($subusers as $postuser) {
557 // this user is subscribed to this forum
558 $subscribedusers[$forumid][$postuser->id] = $postuser->id;
559 $userscount++;
560 if ($userscount > FORUM_CRON_USER_CACHE) {
561 // Store minimal user info.
562 $minuser = new stdClass();
563 $minuser->id = $postuser->id;
564 $users[$postuser->id] = $minuser;
565 } else {
566 // Cache full user record.
567 forum_cron_minimise_user_record($postuser);
568 $users[$postuser->id] = $postuser;
569 }
570 }
571 // Release memory.
572 unset($subusers);
573 unset($postuser);
574 }
575 }
576 $mailcount[$pid] = 0;
577 $errorcount[$pid] = 0;
578 }
579 }
580
581 if ($users && $posts) {
582
583 $urlinfo = parse_url($CFG->wwwroot);
584 $hostname = $urlinfo['host'];
585
586 foreach ($users as $userto) {
587 // Terminate if processing of any account takes longer than 2 minutes.
588 core_php_time_limit::raise(120);
589
590 mtrace('Processing user ' . $userto->id);
591
592 // Init user caches - we keep the cache for one cycle only, otherwise it could consume too much memory.
593 if (isset($userto->username)) {
594 $userto = clone($userto);
595 } else {
596 $userto = $DB->get_record('user', array('id' => $userto->id));
597 forum_cron_minimise_user_record($userto);
598 }
599 $userto->viewfullnames = array();
600 $userto->canpost = array();
601 $userto->markposts = array();
602
603 // Setup this user so that the capabilities are cached, and environment matches receiving user.
604 cron_setup_user($userto);
605
606 // Reset the caches.
607 foreach ($coursemodules as $forumid => $unused) {
608 $coursemodules[$forumid]->cache = new stdClass();
609 $coursemodules[$forumid]->cache->caps = array();
610 unset($coursemodules[$forumid]->uservisible);
611 }
612
613 foreach ($posts as $pid => $post) {
614 $discussion = $discussions[$post->discussion];
615 $forum = $forums[$discussion->forum];
616 $course = $courses[$forum->course];
617 $cm =& $coursemodules[$forum->id];
618
619 // Do some checks to see if we can bail out now.
620
621 // Only active enrolled users are in the list of subscribers.
622 // This does not necessarily mean that the user is subscribed to the forum or to the discussion though.
623 if (!isset($subscribedusers[$forum->id][$userto->id])) {
624 // The user does not subscribe to this forum.
625 continue;
626 }
627
628 if (!\mod_forum\subscriptions::is_subscribed($userto->id, $forum, $post->discussion, $coursemodules[$forum->id])) {
629 // The user does not subscribe to this forum, or to this specific discussion.
630 continue;
631 }
632
633 if ($subscriptiontime = \mod_forum\subscriptions::fetch_discussion_subscription($forum->id, $userto->id)) {
634 // Skip posts if the user subscribed to the discussion after it was created.
635 if (isset($subscriptiontime[$post->discussion]) && ($subscriptiontime[$post->discussion] > $post->created)) {
636 continue;
637 }
638 }
639
640 // Don't send email if the forum is Q&A and the user has not posted.
641 // Initial topics are still mailed.
642 if ($forum->type == 'qanda' && !forum_get_user_posted_time($discussion->id, $userto->id) && $pid != $discussion->firstpost) {
643 mtrace('Did not email ' . $userto->id.' because user has not posted in discussion');
644 continue;
645 }
646
647 // Get info about the sending user.
648 if (array_key_exists($post->userid, $users)) {
649 // We might know the user already.
650 $userfrom = $users[$post->userid];
651 if (!isset($userfrom->idnumber)) {
652 // Minimalised user info, fetch full record.
653 $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
654 forum_cron_minimise_user_record($userfrom);
655 }
656
657 } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
658 forum_cron_minimise_user_record($userfrom);
659 // Fetch only once if possible, we can add it to user list, it will be skipped anyway.
660 if ($userscount <= FORUM_CRON_USER_CACHE) {
661 $userscount++;
662 $users[$userfrom->id] = $userfrom;
663 }
664 } else {
665 mtrace('Could not find user ' . $post->userid . ', author of post ' . $post->id . '. Unable to send message.');
666 continue;
667 }
668
669 // Note: If we want to check that userto and userfrom are not the same person this is probably the spot to do it.
670
671 // Setup global $COURSE properly - needed for roles and languages.
672 cron_setup_user($userto, $course);
673
674 // Fill caches.
675 if (!isset($userto->viewfullnames[$forum->id])) {
676 $modcontext = context_module::instance($cm->id);
677 $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
678 }
679 if (!isset($userto->canpost[$discussion->id])) {
680 $modcontext = context_module::instance($cm->id);
681 $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
682 }
683 if (!isset($userfrom->groups[$forum->id])) {
684 if (!isset($userfrom->groups)) {
685 $userfrom->groups = array();
686 if (isset($users[$userfrom->id])) {
687 $users[$userfrom->id]->groups = array();
688 }
689 }
690 $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
691 if (isset($users[$userfrom->id])) {
692 $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
693 }
694 }
695
696 // Make sure groups allow this user to see this email.
697 if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {
698 // Groups are being used.
699 if (!groups_group_exists($discussion->groupid)) {
700 // Can't find group - be safe and don't this message.
701 continue;
702 }
703
704 if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $modcontext)) {
705 // Do not send posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS.
706 continue;
707 }
708 }
709
710 // Make sure we're allowed to see the post.
711 if (!forum_user_can_see_post($forum, $discussion, $post, null, $cm)) {
712 mtrace('User ' . $userto->id .' can not see ' . $post->id . '. Not sending message.');
713 continue;
714 }
715
716 // OK so we need to send the email.
717
718 // Does the user want this post in a digest? If so postpone it for now.
719 $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
720
721 if ($maildigest > 0) {
722 // This user wants the mails to be in digest form.
723 $queue = new stdClass();
724 $queue->userid = $userto->id;
725 $queue->discussionid = $discussion->id;
726 $queue->postid = $post->id;
727 $queue->timemodified = $post->created;
728 $DB->insert_record('forum_queue', $queue);
729 continue;
730 }
731
732 // Prepare to actually send the post now, and build up the content.
733
734 $cleanforumname = str_replace('"', "'", strip_tags(format_string($forum->name)));
735
736 $userfrom->customheaders = array (
737 // Headers to make emails easier to track.
738 'Precedence: Bulk',
739 'List-Id: "' . $cleanforumname . '" <moodleforum' . $forum->id . '@' . $hostname.'>',
740 'List-Help: ' . $CFG->wwwroot . '/mod/forum/view.php?f=' . $forum->id,
741 'Message-ID: ' . forum_get_email_message_id($post->id, $userto->id, $hostname),
742 'X-Course-Id: ' . $course->id,
743 'X-Course-Name: ' . format_string($course->fullname, true)
744 );
745
746 if ($post->parent) {
747 // This post is a reply, so add headers for threading (see MDL-22551).
748 $userfrom->customheaders[] = 'In-Reply-To: ' . forum_get_email_message_id($post->parent, $userto->id, $hostname);
749 $userfrom->customheaders[] = 'References: ' . forum_get_email_message_id($post->parent, $userto->id, $hostname);
750 }
751
752 $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
753
754 // Generate a reply-to address from using the Inbound Message handler.
755 $replyaddress = null;
756 if ($userto->canpost[$discussion->id] && array_key_exists($post->id, $messageinboundhandlers)) {
757 $messageinboundgenerator->set_data($post->id, $messageinboundhandlers[$post->id]);
758 $replyaddress = $messageinboundgenerator->generate($userto->id);
759 }
760
761 $a = new stdClass();
762 $a->courseshortname = $shortname;
763 $a->forumname = $cleanforumname;
764 $a->subject = format_string($post->subject, true);
765 $postsubject = html_to_text(get_string('postmailsubject', 'forum', $a), 0);
766 $posttext = forum_make_mail_text($course, $cm, $forum, $discussion, $post, $userfrom, $userto, false,
767 $replyaddress);
768 $posthtml = forum_make_mail_html($course, $cm, $forum, $discussion, $post, $userfrom, $userto,
769 $replyaddress);
770
771 // Send the post now!
772 mtrace('Sending ', '');
773
774 $eventdata = new stdClass();
775 $eventdata->component = 'mod_forum';
776 $eventdata->name = 'posts';
777 $eventdata->userfrom = $userfrom;
778 $eventdata->userto = $userto;
779 $eventdata->subject = $postsubject;
780 $eventdata->fullmessage = $posttext;
781 $eventdata->fullmessageformat = FORMAT_PLAIN;
782 $eventdata->fullmessagehtml = $posthtml;
783 $eventdata->notification = 1;
784 $eventdata->replyto = $replyaddress;
785
786 // If forum_replytouser is not set then send mail using the noreplyaddress.
787 if (empty($CFG->forum_replytouser)) {
788 // Clone userfrom as it is referenced by $users.
789 $cloneduserfrom = clone($userfrom);
790 $cloneduserfrom->email = $CFG->noreplyaddress;
791 $eventdata->userfrom = $cloneduserfrom;
792 }
793
794 $smallmessagestrings = new stdClass();
795 $smallmessagestrings->user = fullname($userfrom);
796 $smallmessagestrings->forumname = "$shortname: " . format_string($forum->name, true) . ": " . $discussion->name;
797 $smallmessagestrings->message = $post->message;
798
799 // Make sure strings are in message recipients language.
800 $eventdata->smallmessage = get_string_manager()->get_string('smallmessage', 'forum', $smallmessagestrings, $userto->lang);
801
802 $contexturl = new moodle_url('/mod/forum/discuss.php', array('d' => $discussion->id), 'p' . $post->id);
803 $eventdata->contexturl = $contexturl->out();
804 $eventdata->contexturlname = $discussion->name;
805
806 $mailresult = message_send($eventdata);
807 if (!$mailresult) {
808 mtrace("Error: mod/forum/lib.php forum_cron(): Could not send out mail for id $post->id to user $userto->id".
809 " ($userto->email) .. not trying again.");
810 $errorcount[$post->id]++;
811 } else {
812 $mailcount[$post->id]++;
813
814 // Mark post as read if forum_usermarksread is set off.
815 if (!$CFG->forum_usermarksread) {
816 $userto->markposts[$post->id] = $post->id;
817 }
818 }
819
820 mtrace('post ' . $post->id . ': ' . $post->subject);
821 }
822
823 // Mark processed posts as read.
824 forum_tp_mark_posts_read($userto, $userto->markposts);
825 unset($userto);
826 }
827 }
828
829 if ($posts) {
830 foreach ($posts as $post) {
831 mtrace($mailcount[$post->id]." users were sent post $post->id, '$post->subject'");
832 if ($errorcount[$post->id]) {
833 $DB->set_field('forum_posts', 'mailed', FORUM_MAILED_ERROR, array('id' => $post->id));
834 }
835 }
836 }
837
838 // release some memory
839 unset($subscribedusers);
840 unset($mailcount);
841 unset($errorcount);
842
843 cron_setup_user();
844
845 $sitetimezone = $CFG->timezone;
846
847 // Now see if there are any digest mails waiting to be sent, and if we should send them
848
849 mtrace('Starting digest processing...');
850
851 core_php_time_limit::raise(300); // terminate if not able to fetch all digests in 5 minutes
852
853 if (!isset($CFG->digestmailtimelast)) { // To catch the first time
854 set_config('digestmailtimelast', 0);
855 }
856
857 $timenow = time();
858 $digesttime = usergetmidnight($timenow, $sitetimezone) + ($CFG->digestmailtime * 3600);
859
860 // Delete any really old ones (normally there shouldn't be any)
861 $weekago = $timenow - (7 * 24 * 3600);
862 $DB->delete_records_select('forum_queue', "timemodified < ?", array($weekago));
863 mtrace ('Cleaned old digest records');
864
865 if ($CFG->digestmailtimelast < $digesttime and $timenow > $digesttime) {
866
867 mtrace('Sending forum digests: '.userdate($timenow, '', $sitetimezone));
868
869 $digestposts_rs = $DB->get_recordset_select('forum_queue', "timemodified < ?", array($digesttime));
870
871 if ($digestposts_rs->valid()) {
872
873 // We have work to do
874 $usermailcount = 0;
875
876 //caches - reuse the those filled before too
877 $discussionposts = array();
878 $userdiscussions = array();
879
880 foreach ($digestposts_rs as $digestpost) {
881 if (!isset($posts[$digestpost->postid])) {
882 if ($post = $DB->get_record('forum_posts', array('id' => $digestpost->postid))) {
883 $posts[$digestpost->postid] = $post;
884 } else {
885 continue;
886 }
887 }
888 $discussionid = $digestpost->discussionid;
889 if (!isset($discussions[$discussionid])) {
890 if ($discussion = $DB->get_record('forum_discussions', array('id' => $discussionid))) {
891 $discussions[$discussionid] = $discussion;
892 } else {
893 continue;
894 }
895 }
896 $forumid = $discussions[$discussionid]->forum;
897 if (!isset($forums[$forumid])) {
898 if ($forum = $DB->get_record('forum', array('id' => $forumid))) {
899 $forums[$forumid] = $forum;
900 } else {
901 continue;
902 }
903 }
904
905 $courseid = $forums[$forumid]->course;
906 if (!isset($courses[$courseid])) {
907 if ($course = $DB->get_record('course', array('id' => $courseid))) {
908 $courses[$courseid] = $course;
909 } else {
910 continue;
911 }
912 }
913
914 if (!isset($coursemodules[$forumid])) {
915 if ($cm = get_coursemodule_from_instance('forum', $forumid, $courseid)) {
916 $coursemodules[$forumid] = $cm;
917 } else {
918 continue;
919 }
920 }
921 $userdiscussions[$digestpost->userid][$digestpost->discussionid] = $digestpost->discussionid;
922 $discussionposts[$digestpost->discussionid][$digestpost->postid] = $digestpost->postid;
923 }
924 $digestposts_rs->close(); /// Finished iteration, let's close the resultset
925
926 // Data collected, start sending out emails to each user
927 foreach ($userdiscussions as $userid => $thesediscussions) {
928
929 core_php_time_limit::raise(120); // terminate if processing of any account takes longer than 2 minutes
930
931 cron_setup_user();
932
933 mtrace(get_string('processingdigest', 'forum', $userid), '... ');
934
935 // First of all delete all the queue entries for this user
936 $DB->delete_records_select('forum_queue', "userid = ? AND timemodified < ?", array($userid, $digesttime));
937
938 // Init user caches - we keep the cache for one cycle only,
939 // otherwise it would unnecessarily consume memory.
940 if (array_key_exists($userid, $users) and isset($users[$userid]->username)) {
941 $userto = clone($users[$userid]);
942 } else {
943 $userto = $DB->get_record('user', array('id' => $userid));
944 forum_cron_minimise_user_record($userto);
945 }
946 $userto->viewfullnames = array();
947 $userto->canpost = array();
948 $userto->markposts = array();
949
950 // Override the language and timezone of the "current" user, so that
951 // mail is customised for the receiver.
952 cron_setup_user($userto);
953
954 $postsubject = get_string('digestmailsubject', 'forum', format_string($site->shortname, true));
955
956 $headerdata = new stdClass();
957 $headerdata->sitename = format_string($site->fullname, true);
958 $headerdata->userprefs = $CFG->wwwroot.'/user/edit.php?id='.$userid.'&amp;course='.$site->id;
959
960 $posttext = get_string('digestmailheader', 'forum', $headerdata)."\n\n";
961 $headerdata->userprefs = '<a target="_blank" href="'.$headerdata->userprefs.'">'.get_string('digestmailprefs', 'forum').'</a>';
962
963 $posthtml = "<head>";
964 /* foreach ($CFG->stylesheets as $stylesheet) {
965 //TODO: MDL-21120
966 $posthtml .= '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'" />'."\n";
967 }*/
968 $posthtml .= "</head>\n<body id=\"email\">\n";
969 $posthtml .= '<p>'.get_string('digestmailheader', 'forum', $headerdata).'</p><br /><hr size="1" noshade="noshade" />';
970
971 foreach ($thesediscussions as $discussionid) {
972
973 core_php_time_limit::raise(120); // to be reset for each post
974
975 $discussion = $discussions[$discussionid];
976 $forum = $forums[$discussion->forum];
977 $course = $courses[$forum->course];
978 $cm = $coursemodules[$forum->id];
979
980 //override language
981 cron_setup_user($userto, $course);
982
983 // Fill caches
984 if (!isset($userto->viewfullnames[$forum->id])) {
985 $modcontext = context_module::instance($cm->id);
986 $userto->viewfullnames[$forum->id] = has_capability('moodle/site:viewfullnames', $modcontext);
987 }
988 if (!isset($userto->canpost[$discussion->id])) {
989 $modcontext = context_module::instance($cm->id);
990 $userto->canpost[$discussion->id] = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
991 }
992
993 $strforums = get_string('forums', 'forum');
994 $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
995 $canreply = $userto->canpost[$discussion->id];
996 $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
997
998 $posttext .= "\n \n";
999 $posttext .= '=====================================================================';
1000 $posttext .= "\n \n";
1001 $posttext .= "$shortname -> $strforums -> ".format_string($forum->name,true);
1002 if ($discussion->name != $forum->name) {
1003 $posttext .= " -> ".format_string($discussion->name,true);
1004 }
1005 $posttext .= "\n";
1006 $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1007 $posttext .= "\n";
1008
1009 $posthtml .= "<p><font face=\"sans-serif\">".
1010 "<a target=\"_blank\" href=\"$CFG->wwwroot/course/view.php?id=$course->id\">$shortname</a> -> ".
1011 "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/index.php?id=$course->id\">$strforums</a> -> ".
1012 "<a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/view.php?f=$forum->id\">".format_string($forum->name,true)."</a>";
1013 if ($discussion->name == $forum->name) {
1014 $posthtml .= "</font></p>";
1015 } else {
1016 $posthtml .= " -> <a target=\"_blank\" href=\"$CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id\">".format_string($discussion->name,true)."</a></font></p>";
1017 }
1018 $posthtml .= '<p>';
1019
1020 $postsarray = $discussionposts[$discussionid];
1021 sort($postsarray);
1022
1023 foreach ($postsarray as $postid) {
1024 $post = $posts[$postid];
1025
1026 if (array_key_exists($post->userid, $users)) { // we might know him/her already
1027 $userfrom = $users[$post->userid];
1028 if (!isset($userfrom->idnumber)) {
1029 $userfrom = $DB->get_record('user', array('id' => $userfrom->id));
1030 forum_cron_minimise_user_record($userfrom);
1031 }
1032
1033 } else if ($userfrom = $DB->get_record('user', array('id' => $post->userid))) {
1034 forum_cron_minimise_user_record($userfrom);
1035 if ($userscount <= FORUM_CRON_USER_CACHE) {
1036 $userscount++;
1037 $users[$userfrom->id] = $userfrom;
1038 }
1039
1040 } else {
1041 mtrace('Could not find user '.$post->userid);
1042 continue;
1043 }
1044
1045 if (!isset($userfrom->groups[$forum->id])) {
1046 if (!isset($userfrom->groups)) {
1047 $userfrom->groups = array();
1048 if (isset($users[$userfrom->id])) {
1049 $users[$userfrom->id]->groups = array();
1050 }
1051 }
1052 $userfrom->groups[$forum->id] = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
1053 if (isset($users[$userfrom->id])) {
1054 $users[$userfrom->id]->groups[$forum->id] = $userfrom->groups[$forum->id];
1055 }
1056 }
1057
1058 $userfrom->customheaders = array ("Precedence: Bulk");
1059
1060 $maildigest = forum_get_user_maildigest_bulk($digests, $userto, $forum->id);
1061 if ($maildigest == 2) {
1062 // Subjects and link only
1063 $posttext .= "\n";
1064 $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1065 $by = new stdClass();
1066 $by->name = fullname($userfrom);
1067 $by->date = userdate($post->modified);
1068 $posttext .= "\n".format_string($post->subject,true).' '.get_string("bynameondate", "forum", $by);
1069 $posttext .= "\n---------------------------------------------------------------------";
1070
1071 $by->name = "<a target=\"_blank\" href=\"$CFG->wwwroot/user/view.php?id=$userfrom->id&amp;course=$course->id\">$by->name</a>";
1072 $posthtml .= '<div><a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id.'#p'.$post->id.'">'.format_string($post->subject,true).'</a> '.get_string("bynameondate", "forum", $by).'</div>';
1073
1074 } else {
1075 // The full treatment
1076 $posttext .= forum_make_mail_text($course, $cm, $forum, $discussion, $post, $userfrom, $userto, true);
1077 $posthtml .= forum_make_mail_post($course, $cm, $forum, $discussion, $post, $userfrom, $userto, false, $canreply, true, false);
1078
1079 // Create an array of postid's for this user to mark as read.
1080 if (!$CFG->forum_usermarksread) {
1081 $userto->markposts[$post->id] = $post->id;
1082 }
1083 }
1084 }
1085 $footerlinks = array();
1086 if ($canunsubscribe) {
1087 $footerlinks[] = "<a href=\"$CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id\">" . get_string("unsubscribe", "forum") . "</a>";
1088 } else {
1089 $footerlinks[] = get_string("everyoneissubscribed", "forum");
1090 }
1091 $footerlinks[] = "<a href='{$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}'>" . get_string("digestmailpost", "forum") . '</a>';
1092 $posthtml .= "\n<div class='mdl-right'><font size=\"1\">" . implode('&nbsp;', $footerlinks) . '</font></div>';
1093 $posthtml .= '<hr size="1" noshade="noshade" /></p>';
1094 }
1095 $posthtml .= '</body>';
1096
1097 if (empty($userto->mailformat) || $userto->mailformat != 1) {
1098 // This user DOESN'T want to receive HTML
1099 $posthtml = '';
1100 }
1101
1102 $attachment = $attachname='';
1103 // Directly email forum digests rather than sending them via messaging, use the
1104 // site shortname as 'from name', the noreply address will be used by email_to_user.
1105 $mailresult = email_to_user($userto, $site->shortname, $postsubject, $posttext, $posthtml, $attachment, $attachname);
1106
1107 if (!$mailresult) {
1108 mtrace("ERROR: mod/forum/cron.php: Could not send out digest mail to user $userto->id ".
1109 "($userto->email)... not trying again.");
1110 } else {
1111 mtrace("success.");
1112 $usermailcount++;
1113
1114 // Mark post as read if forum_usermarksread is set off
1115 forum_tp_mark_posts_read($userto, $userto->markposts);
1116 }
1117 }
1118 }
1119 /// We have finishied all digest emails, update $CFG->digestmailtimelast
1120 set_config('digestmailtimelast', $timenow);
1121 }
1122
1123 cron_setup_user();
1124
1125 if (!empty($usermailcount)) {
1126 mtrace(get_string('digestsentusers', 'forum', $usermailcount));
1127 }
1128
1129 if (!empty($CFG->forum_lastreadclean)) {
1130 $timenow = time();
1131 if ($CFG->forum_lastreadclean + (24*3600) < $timenow) {
1132 set_config('forum_lastreadclean', $timenow);
1133 mtrace('Removing old forum read tracking info...');
1134 forum_tp_clean_read_records();
1135 }
1136 } else {
1137 set_config('forum_lastreadclean', time());
1138 }
1139
1140 return true;
1141 }
1142
1143 /**
1144 * Builds and returns the body of the email notification in plain text.
1145 *
1146 * @global object
1147 * @global object
1148 * @uses CONTEXT_MODULE
1149 * @param object $course
1150 * @param object $cm
1151 * @param object $forum
1152 * @param object $discussion
1153 * @param object $post
1154 * @param object $userfrom
1155 * @param object $userto
1156 * @param boolean $bare
1157 * @param string $replyaddress The inbound address that a user can reply to the generated e-mail with. [Since 2.8].
1158 * @return string The email body in plain text format.
1159 */
1160 function forum_make_mail_text($course, $cm, $forum, $discussion, $post, $userfrom, $userto, $bare = false, $replyaddress = null) {
1161 global $CFG, $USER;
1162
1163 $modcontext = context_module::instance($cm->id);
1164
1165 if (!isset($userto->viewfullnames[$forum->id])) {
1166 $viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
1167 } else {
1168 $viewfullnames = $userto->viewfullnames[$forum->id];
1169 }
1170
1171 if (!isset($userto->canpost[$discussion->id])) {
1172 $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course, $modcontext);
1173 } else {
1174 $canreply = $userto->canpost[$discussion->id];
1175 }
1176
1177 $by = New stdClass;
1178 $by->name = fullname($userfrom, $viewfullnames);
1179 $by->date = userdate($post->modified, "", $userto->timezone);
1180
1181 $strbynameondate = get_string('bynameondate', 'forum', $by);
1182
1183 $strforums = get_string('forums', 'forum');
1184
1185 $canunsubscribe = !\mod_forum\subscriptions::is_forcesubscribed($forum);
1186
1187 $posttext = '';
1188
1189 if (!$bare) {
1190 $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1191 $posttext .= "$shortname -> $strforums -> ".format_string($forum->name,true);
1192
1193 if ($discussion->name != $forum->name) {
1194 $posttext .= " -> ".format_string($discussion->name,true);
1195 }
1196 }
1197
1198 // add absolute file links
1199 $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
1200
1201 $posttext .= "\n";
1202 $posttext .= $CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id;
1203 $posttext .= "\n---------------------------------------------------------------------\n";
1204 $posttext .= format_string($post->subject,true);
1205 if ($bare) {
1206 $posttext .= " ($CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id#p$post->id)";
1207 }
1208 $posttext .= "\n".$strbynameondate."\n";
1209 $posttext .= "---------------------------------------------------------------------\n";
1210 $posttext .= format_text_email($post->message, $post->messageformat);
1211 $posttext .= "\n\n";
1212 $posttext .= forum_print_attachments($post, $cm, "text");
1213
1214 if (!$bare) {
1215 if ($canreply) {
1216 $posttext .= "---------------------------------------------------------------------\n";
1217 $posttext .= get_string("postmailinfo", "forum", $shortname)."\n";
1218 $posttext .= "$CFG->wwwroot/mod/forum/post.php?reply=$post->id\n";
1219 }
1220
1221 if ($canunsubscribe) {
1222 if (\mod_forum\subscriptions::is_subscribed($userto->id, $forum, null, $cm)) {
1223 // If subscribed to this forum, offer the unsubscribe link.
1224 $posttext .= "\n---------------------------------------------------------------------\n";
1225 $posttext .= get_string("unsubscribe", "forum");
1226 $posttext .= ": $CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id\n";
1227 }
1228 // Always offer the unsubscribe from discussion link.
1229 $posttext .= "\n---------------------------------------------------------------------\n";
1230 $posttext .= get_string("unsubscribediscussion", "forum");
1231 $posttext .= ": $CFG->wwwroot/mod/forum/subscribe.php?id=$forum->id&d=$discussion->id\n";
1232 }
1233 }
1234
1235 $posttext .= "\n---------------------------------------------------------------------\n";
1236 $posttext .= get_string("digestmailpost", "forum");
1237 $posttext .= ": {$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}\n";
1238
1239 if ($replyaddress) {
1240 $posttext .= "\n\n" . get_string('replytopostbyemail', 'mod_forum');
1241 }
1242
1243 return $posttext;
1244 }
1245
1246 /**
1247 * Builds and returns the body of the email notification in html format.
1248 *
1249 * @global object
1250 * @param object $course
1251 * @param object $cm
1252 * @param object $forum
1253 * @param object $discussion
1254 * @param object $post
1255 * @param object $userfrom
1256 * @param object $userto
1257 * @param string $replyaddress The inbound address that a user can reply to the generated e-mail with. [Since 2.8].
1258 * @return string The email text in HTML format
1259 */
1260 function forum_make_mail_html($course, $cm, $forum, $discussion, $post, $userfrom, $userto, $replyaddress = null) {
1261 global $CFG;
1262
1263 if ($userto->mailformat != 1) { // Needs to be HTML
1264 return '';
1265 }
1266
1267 if (!isset($userto->canpost[$discussion->id])) {
1268 $canreply = forum_user_can_post($forum, $discussion, $userto, $cm, $course);
1269 } else {
1270 $canreply = $userto->canpost[$discussion->id];
1271 }
1272
1273 $strforums = get_string('forums', 'forum');
1274 $canunsubscribe = ! \mod_forum\subscriptions::is_forcesubscribed($forum);
1275 $shortname = format_string($course->shortname, true, array('context' => context_course::instance($course->id)));
1276
1277 $posthtml = '<head>';
1278 /* foreach ($CFG->stylesheets as $stylesheet) {
1279 //TODO: MDL-21120
1280 $posthtml .= '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'" />'."\n";
1281 }*/
1282 $posthtml .= '</head>';
1283 $posthtml .= "\n<body id=\"email\">\n\n";
1284
1285 $posthtml .= '<div class="navbar">'.
1286 '<a target="_blank" href="'.$CFG->wwwroot.'/course/view.php?id='.$course->id.'">'.$shortname.'</a> &raquo; '.
1287 '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/index.php?id='.$course->id.'">'.$strforums.'</a> &raquo; '.
1288 '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.format_string($forum->name,true).'</a>';
1289 if ($discussion->name == $forum->name) {
1290 $posthtml .= '</div>';
1291 } else {
1292 $posthtml .= ' &raquo; <a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$discussion->id.'">'.
1293 format_string($discussion->name,true).'</a></div>';
1294 }
1295 $posthtml .= forum_make_mail_post($course, $cm, $forum, $discussion, $post, $userfrom, $userto, false, $canreply, true, false);
1296
1297 if ($replyaddress) {
1298 $posthtml .= html_writer::tag('p', get_string('replytopostbyemail', 'mod_forum'));
1299 }
1300
1301 $footerlinks = array();
1302 if ($canunsubscribe) {
1303 if (\mod_forum\subscriptions::is_subscribed($userto->id, $forum, null, $cm)) {
1304 // If subscribed to this forum, offer the unsubscribe link.
1305 $unsublink = new moodle_url('/mod/forum/subscribe.php', array('id' => $forum->id));
1306 $footerlinks[] = html_writer::link($unsublink, get_string('unsubscribe', 'mod_forum'));
1307 }
1308 // Always offer the unsubscribe from discussion link.
1309 $unsublink = new moodle_url('/mod/forum/subscribe.php', array(
1310 'id' => $forum->id,
1311 'd' => $discussion->id,
1312 ));
1313 $footerlinks[] = html_writer::link($unsublink, get_string('unsubscribediscussion', 'mod_forum'));
1314
1315 $footerlinks[] = '<a href="' . $CFG->wwwroot . '/mod/forum/unsubscribeall.php">' . get_string('unsubscribeall', 'forum') . '</a>';
1316 }
1317 $footerlinks[] = "<a href='{$CFG->wwwroot}/mod/forum/index.php?id={$forum->course}'>" . get_string('digestmailpost', 'forum') . '</a>';
1318 $posthtml .= '<hr /><div class="mdl-align unsubscribelink">' . implode('&nbsp;', $footerlinks) . '</div>';
1319
1320 $posthtml .= '</body>';
1321
1322 return $posthtml;
1323 }
1324
1325
1326 /**
1327 *
1328 * @param object $course
1329 * @param object $user
1330 * @param object $mod TODO this is not used in this function, refactor
1331 * @param object $forum
1332 * @return object A standard object with 2 variables: info (number of posts for this user) and time (last modified)
1333 */
1334 function forum_user_outline($course, $user, $mod, $forum) {
1335 global $CFG;
1336 require_once("$CFG->libdir/gradelib.php");
1337 $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1338 if (empty($grades->items[0]->grades)) {
1339 $grade = false;
1340 } else {
1341 $grade = reset($grades->items[0]->grades);
1342 }
1343
1344 $count = forum_count_user_posts($forum->id, $user->id);
1345
1346 if ($count && $count->postcount > 0) {
1347 $result = new stdClass();
1348 $result->info = get_string("numposts", "forum", $count->postcount);
1349 $result->time = $count->lastpost;
1350 if ($grade) {
1351 $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1352 }
1353 return $result;
1354 } else if ($grade) {
1355 $result = new stdClass();
1356 $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1357
1358 //datesubmitted == time created. dategraded == time modified or time overridden
1359 //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1360 //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1361 if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1362 $result->time = $grade->dategraded;
1363 } else {
1364 $result->time = $grade->datesubmitted;
1365 }
1366
1367 return $result;
1368 }
1369 return NULL;
1370 }
1371
1372
1373 /**
1374 * @global object
1375 * @global object
1376 * @param object $coure
1377 * @param object $user
1378 * @param object $mod
1379 * @param object $forum
1380 */
1381 function forum_user_complete($course, $user, $mod, $forum) {
1382 global $CFG,$USER, $OUTPUT;
1383 require_once("$CFG->libdir/gradelib.php");
1384
1385 $grades = grade_get_grades($course->id, 'mod', 'forum', $forum->id, $user->id);
1386 if (!empty($grades->items[0]->grades)) {
1387 $grade = reset($grades->items[0]->grades);
1388 echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1389 if ($grade->str_feedback) {
1390 echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1391 }
1392 }
1393
1394 if ($posts = forum_get_user_posts($forum->id, $user->id)) {
1395
1396 if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $course->id)) {
1397 print_error('invalidcoursemodule');
1398 }
1399 $discussions = forum_get_user_involved_discussions($forum->id, $user->id);
1400
1401 foreach ($posts as $post) {
1402 if (!isset($discussions[$post->discussion])) {
1403 continue;
1404 }
1405 $discussion = $discussions[$post->discussion];
1406
1407 forum_print_post($post, $discussion, $forum, $cm, $course, false, false, false);
1408 }
1409 } else {
1410 echo "<p>".get_string("noposts", "forum")."</p>";
1411 }
1412 }
1413
1414 /**
1415 * Filters the forum discussions according to groups membership and config.
1416 *
1417 * @since Moodle 2.8, 2.7.1, 2.6.4
1418 * @param array $discussions Discussions with new posts array
1419 * @return array Forums with the number of new posts
1420 */
1421 function forum_filter_user_groups_discussions($discussions) {
1422
1423 // Group the remaining discussions posts by their forumid.
1424 $filteredforums = array();
1425
1426 // Discard not visible groups.
1427 foreach ($discussions as $discussion) {
1428
1429 // Course data is already cached.
1430 $instances = get_fast_modinfo($discussion->course)->get_instances();
1431 $forum = $instances['forum'][$discussion->forum];
1432
1433 // Continue if the user should not see this discussion.
1434 if (!forum_is_user_group_discussion($forum, $discussion->groupid)) {
1435 continue;
1436 }
1437
1438 // Grouping results by forum.
1439 if (empty($filteredforums[$forum->instance])) {
1440 $filteredforums[$forum->instance] = new stdClass();
1441 $filteredforums[$forum->instance]->id = $forum->id;
1442 $filteredforums[$forum->instance]->count = 0;
1443 }
1444 $filteredforums[$forum->instance]->count += $discussion->count;
1445
1446 }
1447
1448 return $filteredforums;
1449 }
1450
1451 /**
1452 * Returns whether the discussion group is visible by the current user or not.
1453 *
1454 * @since Moodle 2.8, 2.7.1, 2.6.4
1455 * @param cm_info $cm The discussion course module
1456 * @param int $discussiongroupid The discussion groupid
1457 * @return bool
1458 */
1459 function forum_is_user_group_discussion(cm_info $cm, $discussiongroupid) {
1460
1461 if ($discussiongroupid == -1 || $cm->effectivegroupmode != SEPARATEGROUPS) {
1462 return true;
1463 }
1464
1465 if (isguestuser()) {
1466 return false;
1467 }
1468
1469 if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id)) ||
1470 in_array($discussiongroupid, $cm->get_modinfo()->get_groups($cm->groupingid))) {
1471 return true;
1472 }
1473
1474 return false;
1475 }
1476
1477 /**
1478 * @global object
1479 * @global object
1480 * @global object
1481 * @param array $courses
1482 * @param array $htmlarray
1483 */
1484 function forum_print_overview($courses,&$htmlarray) {
1485 global $USER, $CFG, $DB, $SESSION;
1486
1487 if (empty($courses) || !is_array($courses) || count($courses) == 0) {
1488 return array();
1489 }
1490
1491 if (!$forums = get_all_instances_in_courses('forum',$courses)) {
1492 return;
1493 }
1494
1495 // Courses to search for new posts
1496 $coursessqls = array();
1497 $params = array();
1498 foreach ($courses as $course) {
1499
1500 // If the user has never entered into the course all posts are pending
1501 if ($course->lastaccess == 0) {
1502 $coursessqls[] = '(d.course = ?)';
1503 $params[] = $course->id;
1504
1505 // Only posts created after the course last access
1506 } else {
1507 $coursessqls[] = '(d.course = ? AND p.created > ?)';
1508 $params[] = $course->id;
1509 $params[] = $course->lastaccess;
1510 }
1511 }
1512 $params[] = $USER->id;
1513 $coursessql = implode(' OR ', $coursessqls);
1514
1515 $sql = "SELECT d.id, d.forum, d.course, d.groupid, COUNT(*) as count "
1516 .'FROM {forum_discussions} d '
1517 .'JOIN {forum_posts} p ON p.discussion = d.id '
1518 ."WHERE ($coursessql) "
1519 .'AND p.userid != ? '
1520 .'GROUP BY d.id, d.forum, d.course, d.groupid '
1521 .'ORDER BY d.course, d.forum';
1522
1523 // Avoid warnings.
1524 if (!$discussions = $DB->get_records_sql($sql, $params)) {
1525 $discussions = array();
1526 }
1527
1528 $forumsnewposts = forum_filter_user_groups_discussions($discussions);
1529
1530 // also get all forum tracking stuff ONCE.
1531 $trackingforums = array();
1532 foreach ($forums as $forum) {
1533 if (forum_tp_can_track_forums($forum)) {
1534 $trackingforums[$forum->id] = $forum;
1535 }
1536 }
1537
1538 if (count($trackingforums) > 0) {
1539 $cutoffdate = isset($CFG->forum_oldpostdays) ? (time() - ($CFG->forum_oldpostdays*24*60*60)) : 0;
1540 $sql = 'SELECT d.forum,d.course,COUNT(p.id) AS count '.
1541 ' FROM {forum_posts} p '.
1542 ' JOIN {forum_discussions} d ON p.discussion = d.id '.
1543 ' LEFT JOIN {forum_read} r ON r.postid = p.id AND r.userid = ? WHERE (';
1544 $params = array($USER->id);
1545
1546 foreach ($trackingforums as $track) {
1547 $sql .= '(d.forum = ? AND (d.groupid = -1 OR d.groupid = 0 OR d.groupid = ?)) OR ';
1548 $params[] = $track->id;
1549 if (isset($SESSION->currentgroup[$track->course])) {
1550 $groupid = $SESSION->currentgroup[$track->course];
1551 } else {
1552 // get first groupid
1553 $groupids = groups_get_all_groups($track->course, $USER->id);
1554 if ($groupids) {
1555 reset($groupids);
1556 $groupid = key($groupids);
1557 $SESSION->currentgroup[$track->course] = $groupid;
1558 } else {
1559 $groupid = 0;
1560 }
1561 unset($groupids);
1562 }
1563 $params[] = $groupid;
1564 }
1565 $sql = substr($sql,0,-3); // take off the last OR
1566 $sql .= ') AND p.modified >= ? AND r.id is NULL GROUP BY d.forum,d.course';
1567 $params[] = $cutoffdate;
1568
1569 if (!$unread = $DB->get_records_sql($sql, $params)) {
1570 $unread = array();
1571 }
1572 } else {
1573 $unread = array();
1574 }
1575
1576 if (empty($unread) and empty($forumsnewposts)) {
1577 return;
1578 }
1579
1580 $strforum = get_string('modulename','forum');
1581
1582 foreach ($forums as $forum) {
1583 $str = '';
1584 $count = 0;
1585 $thisunread = 0;
1586 $showunread = false;
1587 // either we have something from logs, or trackposts, or nothing.
1588 if (array_key_exists($forum->id, $forumsnewposts) && !empty($forumsnewposts[$forum->id])) {
1589 $count = $forumsnewposts[$forum->id]->count;
1590 }
1591 if (array_key_exists($forum->id,$unread)) {
1592 $thisunread = $unread[$forum->id]->count;
1593 $showunread = true;
1594 }
1595 if ($count > 0 || $thisunread > 0) {
1596 $str .= '<div class="overview forum"><div class="name">'.$strforum.': <a title="'.$strforum.'" href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'">'.
1597 $forum->name.'</a></div>';
1598 $str .= '<div class="info"><span class="postsincelogin">';
1599 $str .= get_string('overviewnumpostssince', 'forum', $count)."</span>";
1600 if (!empty($showunread)) {
1601 $str .= '<div class="unreadposts">'.get_string('overviewnumunread', 'forum', $thisunread).'</div>';
1602 }
1603 $str .= '</div></div>';
1604 }
1605 if (!empty($str)) {
1606 if (!array_key_exists($forum->course,$htmlarray)) {
1607 $htmlarray[$forum->course] = array();
1608 }
1609 if (!array_key_exists('forum',$htmlarray[$forum->course])) {
1610 $htmlarray[$forum->course]['forum'] = ''; // initialize, avoid warnings
1611 }
1612 $htmlarray[$forum->course]['forum'] .= $str;
1613 }
1614 }
1615 }
1616
1617 /**
1618 * Given a course and a date, prints a summary of all the new
1619 * messages posted in the course since that date
1620 *
1621 * @global object
1622 * @global object
1623 * @global object
1624 * @uses CONTEXT_MODULE
1625 * @uses VISIBLEGROUPS
1626 * @param object $course
1627 * @param bool $viewfullnames capability
1628 * @param int $timestart
1629 * @return bool success
1630 */
1631 function forum_print_recent_activity($course, $viewfullnames, $timestart) {
1632 global $CFG, $USER, $DB, $OUTPUT;
1633
1634 // do not use log table if possible, it may be huge and is expensive to join with other tables
1635
1636 $allnamefields = user_picture::fields('u', null, 'duserid');
1637 if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
1638 d.timestart, d.timeend, $allnamefields
1639 FROM {forum_posts} p
1640 JOIN {forum_discussions} d ON d.id = p.discussion
1641 JOIN {forum} f ON f.id = d.forum
1642 JOIN {user} u ON u.id = p.userid
1643 WHERE p.created > ? AND f.course = ?
1644 ORDER BY p.id ASC", array($timestart, $course->id))) { // order by initial posting date
1645 return false;
1646 }
1647
1648 $modinfo = get_fast_modinfo($course);
1649
1650 $groupmodes = array();
1651 $cms = array();
1652
1653 $strftimerecent = get_string('strftimerecent');
1654
1655 $printposts = array();
1656 foreach ($posts as $post) {
1657 if (!isset($modinfo->instances['forum'][$post->forum])) {
1658 // not visible
1659 continue;
1660 }
1661 $cm = $modinfo->instances['forum'][$post->forum];
1662 if (!$cm->uservisible) {
1663 continue;
1664 }
1665 $context = context_module::instance($cm->id);
1666
1667 if (!has_capability('mod/forum:viewdiscussion', $context)) {
1668 continue;
1669 }
1670
1671 if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
1672 and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
1673 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
1674 continue;
1675 }
1676 }
1677
1678 // Check that the user can see the discussion.
1679 if (forum_is_user_group_discussion($cm, $post->groupid)) {
1680 $printposts[] = $post;
1681 }
1682
1683 }
1684 unset($posts);
1685
1686 if (!$printposts) {
1687 return false;
1688 }
1689
1690 echo $OUTPUT->heading(get_string('newforumposts', 'forum').':', 3);
1691 echo "\n<ul class='unlist'>\n";
1692
1693 foreach ($printposts as $post) {
1694 $subjectclass = empty($post->parent) ? ' bold' : '';
1695
1696 echo '<li><div class="head">'.
1697 '<div class="date">'.userdate($post->modified, $strftimerecent).'</div>'.
1698 '<div class="name">'.fullname($post, $viewfullnames).'</div>'.
1699 '</div>';
1700 echo '<div class="info'.$subjectclass.'">';
1701 if (empty($post->parent)) {
1702 echo '"<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
1703 } else {
1704 echo '"<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'&amp;parent='.$post->parent.'#p'.$post->id.'">';
1705 }
1706 $post->subject = break_up_long_words(format_string($post->subject, true));
1707 echo $post->subject;
1708 echo "</a>\"</div></li>\n";
1709 }
1710
1711 echo "</ul>\n";
1712
1713 return true;
1714 }
1715
1716 /**
1717 * Return grade for given user or all users.
1718 *
1719 * @global object
1720 * @global object
1721 * @param object $forum
1722 * @param int $userid optional user id, 0 means all users
1723 * @return array array of grades, false if none
1724 */
1725 function forum_get_user_grades($forum, $userid = 0) {
1726 global $CFG;
1727
1728 require_once($CFG->dirroot.'/rating/lib.php');
1729
1730 $ratingoptions = new stdClass;
1731 $ratingoptions->component = 'mod_forum';
1732 $ratingoptions->ratingarea = 'post';
1733
1734 //need these to work backwards to get a context id. Is there a better way to get contextid from a module instance?
1735 $ratingoptions->modulename = 'forum';
1736 $ratingoptions->moduleid = $forum->id;
1737 $ratingoptions->userid = $userid;
1738 $ratingoptions->aggregationmethod = $forum->assessed;
1739 $ratingoptions->scaleid = $forum->scale;
1740 $ratingoptions->itemtable = 'forum_posts';
1741 $ratingoptions->itemtableusercolumn = 'userid';
1742
1743 $rm = new rating_manager();
1744 return $rm->get_user_grades($ratingoptions);
1745 }
1746
1747 /**
1748 * Update activity grades
1749 *
1750 * @category grade
1751 * @param object $forum
1752 * @param int $userid specific user only, 0 means all
1753 * @param boolean $nullifnone return null if grade does not exist
1754 * @return void
1755 */
1756 function forum_update_grades($forum, $userid=0, $nullifnone=true) {
1757 global $CFG, $DB;
1758 require_once($CFG->libdir.'/gradelib.php');
1759
1760 if (!$forum->assessed) {
1761 forum_grade_item_update($forum);
1762
1763 } else if ($grades = forum_get_user_grades($forum, $userid)) {
1764 forum_grade_item_update($forum, $grades);
1765
1766 } else if ($userid and $nullifnone) {
1767 $grade = new stdClass();
1768 $grade->userid = $userid;
1769 $grade->rawgrade = NULL;
1770 forum_grade_item_update($forum, $grade);
1771
1772 } else {
1773 forum_grade_item_update($forum);
1774 }
1775 }
1776
1777 /**
1778 * Create/update grade item for given forum
1779 *
1780 * @category grade
1781 * @uses GRADE_TYPE_NONE
1782 * @uses GRADE_TYPE_VALUE
1783 * @uses GRADE_TYPE_SCALE
1784 * @param stdClass $forum Forum object with extra cmidnumber
1785 * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1786 * @return int 0 if ok
1787 */
1788 function forum_grade_item_update($forum, $grades=NULL) {
1789 global $CFG;
1790 if (!function_exists('grade_update')) { //workaround for buggy PHP versions
1791 require_once($CFG->libdir.'/gradelib.php');
1792 }
1793
1794 $params = array('itemname'=>$forum->name, 'idnumber'=>$forum->cmidnumber);
1795
1796 if (!$forum->assessed or $forum->scale == 0) {
1797 $params['gradetype'] = GRADE_TYPE_NONE;
1798
1799 } else if ($forum->scale > 0) {
1800 $params['gradetype'] = GRADE_TYPE_VALUE;
1801 $params['grademax'] = $forum->scale;
1802 $params['grademin'] = 0;
1803
1804 } else if ($forum->scale < 0) {
1805 $params['gradetype'] = GRADE_TYPE_SCALE;
1806 $params['scaleid'] = -$forum->scale;
1807 }
1808
1809 if ($grades === 'reset') {
1810 $params['reset'] = true;
1811 $grades = NULL;
1812 }
1813
1814 return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, $grades, $params);
1815 }
1816
1817 /**
1818 * Delete grade item for given forum
1819 *
1820 * @category grade
1821 * @param stdClass $forum Forum object
1822 * @return grade_item
1823 */
1824 function forum_grade_item_delete($forum) {
1825 global $CFG;
1826 require_once($CFG->libdir.'/gradelib.php');
1827
1828 return grade_update('mod/forum', $forum->course, 'mod', 'forum', $forum->id, 0, NULL, array('deleted'=>1));
1829 }
1830
1831
1832 /**
1833 * This function returns if a scale is being used by one forum
1834 *
1835 * @global object
1836 * @param int $forumid
1837 * @param int $scaleid negative number
1838 * @return bool
1839 */
1840 function forum_scale_used ($forumid,$scaleid) {
1841 global $DB;
1842 $return = false;
1843
1844 $rec = $DB->get_record("forum",array("id" => "$forumid","scale" => "-$scaleid"));
1845
1846 if (!empty($rec) && !empty($scaleid)) {
1847 $return = true;
1848 }
1849
1850 return $return;
1851 }
1852
1853 /**
1854 * Checks if scale is being used by any instance of forum
1855 *
1856 * This is used to find out if scale used anywhere
1857 *
1858 * @global object
1859 * @param $scaleid int
1860 * @return boolean True if the scale is used by any forum
1861 */
1862 function forum_scale_used_anywhere($scaleid) {
1863 global $DB;
1864 if ($scaleid and $DB->record_exists('forum', array('scale' => -$scaleid))) {
1865 return true;
1866 } else {
1867 return false;
1868 }
1869 }
1870
1871 // SQL FUNCTIONS ///////////////////////////////////////////////////////////
1872
1873 /**
1874 * Gets a post with all info ready for forum_print_post
1875 * Most of these joins are just to get the forum id
1876 *
1877 * @global object
1878 * @global object
1879 * @param int $postid
1880 * @return mixed array of posts or false
1881 */
1882 function forum_get_post_full($postid) {
1883 global $CFG, $DB;
1884
1885 $allnames = get_all_user_name_fields(true, 'u');
1886 return $DB->get_record_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
1887 FROM {forum_posts} p
1888 JOIN {forum_discussions} d ON p.discussion = d.id
1889 LEFT JOIN {user} u ON p.userid = u.id
1890 WHERE p.id = ?", array($postid));
1891 }
1892
1893 /**
1894 * Gets all posts in discussion including top parent.
1895 *
1896 * @global object
1897 * @global object
1898 * @global object
1899 * @param int $discussionid
1900 * @param string $sort
1901 * @param bool $tracking does user track the forum?
1902 * @return array of posts
1903 */
1904 function forum_get_all_discussion_posts($discussionid, $sort, $tracking=false) {
1905 global $CFG, $DB, $USER;
1906
1907 $tr_sel = "";
1908 $tr_join = "";
1909 $params = array();
1910
1911 if ($tracking) {
1912 $now = time();
1913 $cutoffdate = $now - ($CFG->forum_oldpostdays * 24 * 3600);
1914 $tr_sel = ", fr.id AS postread";
1915 $tr_join = "LEFT JOIN {forum_read} fr ON (fr.postid = p.id AND fr.userid = ?)";
1916 $params[] = $USER->id;
1917 }
1918
1919 $allnames = get_all_user_name_fields(true, 'u');
1920 $params[] = $discussionid;
1921 if (!$posts = $DB->get_records_sql("SELECT p.*, $allnames, u.email, u.picture, u.imagealt $tr_sel
1922 FROM {forum_posts} p
1923 LEFT JOIN {user} u ON p.userid = u.id
1924 $tr_join
1925 WHERE p.discussion = ?
1926 ORDER BY $sort", $params)) {
1927 return array();
1928 }
1929
1930 foreach ($posts as $pid=>$p) {
1931 if ($tracking) {
1932 if (forum_tp_is_post_old($p)) {
1933 $posts[$pid]->postread = true;
1934 }
1935 }
1936 if (!$p->parent) {
1937 continue;
1938 }
1939 if (!isset($posts[$p->parent])) {
1940 continue; // parent does not exist??
1941 }
1942 if (!isset($posts[$p->parent]->children)) {
1943 $posts[$p->parent]->children = array();
1944 }
1945 $posts[$p->parent]->children[$pid] =& $posts[$pid];
1946 }
1947
1948 return $posts;
1949 }
1950
1951 /**
1952 * An array of forum objects that the user is allowed to read/search through.
1953 *
1954 * @global object
1955 * @global object
1956 * @global object
1957 * @param int $userid
1958 * @param int $courseid if 0, we look for forums throughout the whole site.
1959 * @return array of forum objects, or false if no matches
1960 * Forum objects have the following attributes:
1961 * id, type, course, cmid, cmvisible, cmgroupmode, accessallgroups,
1962 * viewhiddentimedposts
1963 */
1964 function forum_get_readable_forums($userid, $courseid=0) {
1965
1966 global $CFG, $DB, $USER;
1967 require_once($CFG->dirroot.'/course/lib.php');
1968
1969 if (!$forummod = $DB->get_record('modules', array('name' => 'forum'))) {
1970 print_error('notinstalled', 'forum');
1971 }
1972
1973 if ($courseid) {
1974 $courses = $DB->get_records('course', array('id' => $courseid));
1975 } else {
1976 // If no course is specified, then the user can see SITE + his courses.
1977 $courses1 = $DB->get_records('course', array('id' => SITEID));
1978 $courses2 = enrol_get_users_courses($userid, true, array('modinfo'));
1979 $courses = array_merge($courses1, $courses2);
1980 }
1981 if (!$courses) {
1982 return array();
1983 }
1984
1985 $readableforums = array();
1986
1987 foreach ($courses as $course) {
1988
1989 $modinfo = get_fast_modinfo($course);
1990
1991 if (empty($modinfo->instances['forum'])) {
1992 // hmm, no forums?
1993 continue;
1994 }
1995
1996 $courseforums = $DB->get_records('forum', array('course' => $course->id));
1997
1998 foreach ($modinfo->instances['forum'] as $forumid => $cm) {
1999 if (!$cm->uservisible or !isset($courseforums[$forumid])) {
2000 continue;
2001 }
2002 $context = context_module::instance($cm->id);
2003 $forum = $courseforums[$forumid];
2004 $forum->context = $context;
2005 $forum->cm = $cm;
2006
2007 if (!has_capability('mod/forum:viewdiscussion', $context)) {
2008 continue;
2009 }
2010
2011 /// group access
2012 if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
2013
2014 $forum->onlygroups = $modinfo->get_groups($cm->groupingid);
2015 $forum->onlygroups[] = -1;
2016 }
2017
2018 /// hidden timed discussions
2019 $forum->viewhiddentimedposts = true;
2020 if (!empty($CFG->forum_enabletimedposts)) {
2021 if (!has_capability('mod/forum:viewhiddentimedposts', $context)) {
2022 $forum->viewhiddentimedposts = false;
2023 }
2024 }
2025
2026 /// qanda access
2027 if ($forum->type == 'qanda'
2028 && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
2029
2030 // We need to check whether the user has posted in the qanda forum.
2031 $forum->onlydiscussions = array(); // Holds discussion ids for the discussions
2032 // the user is allowed to see in this forum.
2033 if ($discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $USER->id)) {
2034 foreach ($discussionspostedin as $d) {
2035 $forum->onlydiscussions[] = $d->id;
2036 }
2037 }
2038 }
2039
2040 $readableforums[$forum->id] = $forum;
2041 }
2042
2043 unset($modinfo);
2044
2045 } // End foreach $courses
2046
2047 return $readableforums;
2048 }
2049
2050 /**
2051 * Returns a list of posts found using an array of search terms.
2052 *
2053 * @global object
2054 * @global object
2055 * @global object
2056 * @param array $searchterms array of search terms, e.g. word +word -word
2057 * @param int $courseid if 0, we search through the whole site
2058 * @param int $limitfrom
2059 * @param int $limitnum
2060 * @param int &$totalcount
2061 * @param string $extrasql
2062 * @return array|bool Array of posts found or false
2063 */
2064 function forum_search_posts($searchterms, $courseid=0, $limitfrom=0, $limitnum=50,
2065 &$totalcount, $extrasql='') {
2066 global $CFG, $DB, $USER;
2067 require_once($CFG->libdir.'/searchlib.php');
2068
2069 $forums = forum_get_readable_forums($USER->id, $courseid);
2070
2071 if (count($forums) == 0) {
2072 $totalcount = 0;
2073 return false;
2074 }
2075
2076 $now = round(time(), -2); // db friendly
2077
2078 $fullaccess = array();
2079 $where = array();
2080 $params = array();
2081
2082 foreach ($forums as $forumid => $forum) {
2083 $select = array();
2084
2085 if (!$forum->viewhiddentimedposts) {
2086 $select[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
2087 $params = array_merge($params, array('userid'.$forumid=>$USER->id, 'timestart'.$forumid=>$now, 'timeend'.$forumid=>$now));
2088 }
2089
2090 $cm = $forum->cm;
2091 $context = $forum->context;
2092
2093 if ($forum->type == 'qanda'
2094 && !has_capability('mod/forum:viewqandawithoutposting', $context)) {
2095 if (!empty($forum->onlydiscussions)) {
2096 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forum->onlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
2097 $params = array_merge($params, $discussionid_params);
2098 $select[] = "(d.id $discussionid_sql OR p.parent = 0)";
2099 } else {
2100 $select[] = "p.parent = 0";
2101 }
2102 }
2103
2104 if (!empty($forum->onlygroups)) {
2105 list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($forum->onlygroups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
2106 $params = array_merge($params, $groupid_params);
2107 $select[] = "d.groupid $groupid_sql";
2108 }
2109
2110 if ($select) {
2111 $selects = implode(" AND ", $select);
2112 $where[] = "(d.forum = :forum{$forumid} AND $selects)";
2113 $params['forum'.$forumid] = $forumid;
2114 } else {
2115 $fullaccess[] = $forumid;
2116 }
2117 }
2118
2119 if ($fullaccess) {
2120 list($fullid_sql, $fullid_params) = $DB->get_in_or_equal($fullaccess, SQL_PARAMS_NAMED, 'fula');
2121 $params = array_merge($params, $fullid_params);
2122 $where[] = "(d.forum $fullid_sql)";
2123 }
2124
2125 $selectdiscussion = "(".implode(" OR ", $where).")";
2126
2127 $messagesearch = '';
2128 $searchstring = '';
2129
2130 // Need to concat these back together for parser to work.
2131 foreach($searchterms as $searchterm){
2132 if ($searchstring != '') {
2133 $searchstring .= ' ';
2134 }
2135 $searchstring .= $searchterm;
2136 }
2137
2138 // We need to allow quoted strings for the search. The quotes *should* be stripped
2139 // by the parser, but this should be examined carefully for security implications.
2140 $searchstring = str_replace("\\\"","\"",$searchstring);
2141 $parser = new search_parser();
2142 $lexer = new search_lexer($parser);
2143
2144 if ($lexer->parse($searchstring)) {
2145 $parsearray = $parser->get_parsed_array();
2146 // Experimental feature under 1.8! MDL-8830
2147 // Use alternative text searches if defined
2148 // This feature only works under mysql until properly implemented for other DBs
2149 // Requires manual creation of text index for forum_posts before enabling it:
2150 // CREATE FULLTEXT INDEX foru_post_tix ON [prefix]forum_posts (subject, message)
2151 // Experimental feature under 1.8! MDL-8830
2152 if (!empty($CFG->forum_usetextsearches)) {
2153 list($messagesearch, $msparams) = search_generate_text_SQL($parsearray, 'p.message', 'p.subject',
2154 'p.userid', 'u.id', 'u.firstname',
2155 'u.lastname', 'p.modified', 'd.forum');
2156 } else {
2157 list($messagesearch, $msparams) = search_generate_SQL($parsearray, 'p.message', 'p.subject',
2158 'p.userid', 'u.id', 'u.firstname',
2159 'u.lastname', 'p.modified', 'd.forum');
2160 }
2161 $params = array_merge($params, $msparams);
2162 }
2163
2164 $fromsql = "{forum_posts} p,
2165 {forum_discussions} d,
2166 {user} u";
2167
2168 $selectsql = " $messagesearch
2169 AND p.discussion = d.id
2170 AND p.userid = u.id
2171 AND $selectdiscussion
2172 $extrasql";
2173
2174 $countsql = "SELECT COUNT(*)
2175 FROM $fromsql
2176 WHERE $selectsql";
2177
2178 $allnames = get_all_user_name_fields(true, 'u');
2179 $searchsql = "SELECT p.*,
2180 d.forum,
2181 $allnames,
2182 u.email,
2183 u.picture,
2184 u.imagealt
2185 FROM $fromsql
2186 WHERE $selectsql
2187 ORDER BY p.modified DESC";
2188
2189 $totalcount = $DB->count_records_sql($countsql, $params);
2190
2191 return $DB->get_records_sql($searchsql, $params, $limitfrom, $limitnum);
2192 }
2193
2194 /**
2195 * Returns a list of all new posts that have not been mailed yet
2196 *
2197 * @param int $starttime posts created after this time
2198 * @param int $endtime posts created before this
2199 * @param int $now used for timed discussions only
2200 * @return array
2201 */
2202 function forum_get_unmailed_posts($starttime, $endtime, $now=null) {
2203 global $CFG, $DB;
2204
2205 $params = array();
2206 $params['mailed'] = FORUM_MAILED_PENDING;
2207 $params['ptimestart'] = $starttime;
2208 $params['ptimeend'] = $endtime;
2209 $params['mailnow'] = 1;
2210
2211 if (!empty($CFG->forum_enabletimedposts)) {
2212 if (empty($now)) {
2213 $now = time();
2214 }
2215 $timedsql = "AND (d.timestart < :dtimestart AND (d.timeend = 0 OR d.timeend > :dtimeend))";
2216 $params['dtimestart'] = $now;
2217 $params['dtimeend'] = $now;
2218 } else {
2219 $timedsql = "";
2220 }
2221
2222 return $DB->get_records_sql("SELECT p.*, d.course, d.forum
2223 FROM {forum_posts} p
2224 JOIN {forum_discussions} d ON d.id = p.discussion
2225 WHERE p.mailed = :mailed
2226 AND p.created >= :ptimestart
2227 AND (p.created < :ptimeend OR p.mailnow = :mailnow)
2228 $timedsql
2229 ORDER BY p.modified ASC", $params);
2230 }
2231
2232 /**
2233 * Marks posts before a certain time as being mailed already
2234 *
2235 * @global object
2236 * @global object
2237 * @param int $endtime
2238 * @param int $now Defaults to time()
2239 * @return bool
2240 */
2241 function forum_mark_old_posts_as_mailed($endtime, $now=null) {
2242 global $CFG, $DB;
2243
2244 if (empty($now)) {
2245 $now = time();
2246 }
2247
2248 $params = array();
2249 $params['mailedsuccess'] = FORUM_MAILED_SUCCESS;
2250 $params['now'] = $now;
2251 $params['endtime'] = $endtime;
2252 $params['mailnow'] = 1;
2253 $params['mailedpending'] = FORUM_MAILED_PENDING;
2254
2255 if (empty($CFG->forum_enabletimedposts)) {
2256 return $DB->execute("UPDATE {forum_posts}
2257 SET mailed = :mailedsuccess
2258 WHERE (created < :endtime OR mailnow = :mailnow)
2259 AND mailed = :mailedpending", $params);
2260 } else {
2261 return $DB->execute("UPDATE {forum_posts}
2262 SET mailed = :mailedsuccess
2263 WHERE discussion NOT IN (SELECT d.id
2264 FROM {forum_discussions} d
2265 WHERE d.timestart > :now)
2266 AND (created < :endtime OR mailnow = :mailnow)
2267 AND mailed = :mailedpending", $params);
2268 }
2269 }
2270
2271 /**
2272 * Get all the posts for a user in a forum suitable for forum_print_post
2273 *
2274 * @global object
2275 * @global object
2276 * @uses CONTEXT_MODULE
2277 * @return array
2278 */
2279 function forum_get_user_posts($forumid, $userid) {
2280 global $CFG, $DB;
2281
2282 $timedsql = "";
2283 $params = array($forumid, $userid);
2284
2285 if (!empty($CFG->forum_enabletimedposts)) {
2286 $cm = get_coursemodule_from_instance('forum', $forumid);
2287 if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2288 $now = time();
2289 $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2290 $params[] = $now;
2291 $params[] = $now;
2292 }
2293 }
2294
2295 $allnames = get_all_user_name_fields(true, 'u');
2296 return $DB->get_records_sql("SELECT p.*, d.forum, $allnames, u.email, u.picture, u.imagealt
2297 FROM {forum} f
2298 JOIN {forum_discussions} d ON d.forum = f.id
2299 JOIN {forum_posts} p ON p.discussion = d.id
2300 JOIN {user} u ON u.id = p.userid
2301 WHERE f.id = ?
2302 AND p.userid = ?
2303 $timedsql
2304 ORDER BY p.modified ASC", $params);
2305 }
2306
2307 /**
2308 * Get all the discussions user participated in
2309 *
2310 * @global object
2311 * @global object
2312 * @uses CONTEXT_MODULE
2313 * @param int $forumid
2314 * @param int $userid
2315 * @return array Array or false
2316 */
2317 function forum_get_user_involved_discussions($forumid, $userid) {
2318 global $CFG, $DB;
2319
2320 $timedsql = "";
2321 $params = array($forumid, $userid);
2322 if (!empty($CFG->forum_enabletimedposts)) {
2323 $cm = get_coursemodule_from_instance('forum', $forumid);
2324 if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2325 $now = time();
2326 $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2327 $params[] = $now;
2328 $params[] = $now;
2329 }
2330 }
2331
2332 return $DB->get_records_sql("SELECT DISTINCT d.*
2333 FROM {forum} f
2334 JOIN {forum_discussions} d ON d.forum = f.id
2335 JOIN {forum_posts} p ON p.discussion = d.id
2336 WHERE f.id = ?
2337 AND p.userid = ?
2338 $timedsql", $params);
2339 }
2340
2341 /**
2342 * Get all the posts for a user in a forum suitable for forum_print_post
2343 *
2344 * @global object
2345 * @global object
2346 * @param int $forumid
2347 * @param int $userid
2348 * @return array of counts or false
2349 */
2350 function forum_count_user_posts($forumid, $userid) {
2351 global $CFG, $DB;
2352
2353 $timedsql = "";
2354 $params = array($forumid, $userid);
2355 if (!empty($CFG->forum_enabletimedposts)) {
2356 $cm = get_coursemodule_from_instance('forum', $forumid);
2357 if (!has_capability('mod/forum:viewhiddentimedposts' , context_module::instance($cm->id))) {
2358 $now = time();
2359 $timedsql = "AND (d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?))";
2360 $params[] = $now;
2361 $params[] = $now;
2362 }
2363 }
2364
2365 return $DB->get_record_sql("SELECT COUNT(p.id) AS postcount, MAX(p.modified) AS lastpost
2366 FROM {forum} f
2367 JOIN {forum_discussions} d ON d.forum = f.id
2368 JOIN {forum_posts} p ON p.discussion = d.id
2369 JOIN {user} u ON u.id = p.userid
2370 WHERE f.id = ?
2371 AND p.userid = ?
2372 $timedsql", $params);
2373 }
2374
2375 /**
2376 * Given a log entry, return the forum post details for it.
2377 *
2378 * @global object
2379 * @global object
2380 * @param object $log
2381 * @return array|null
2382 */
2383 function forum_get_post_from_log($log) {
2384 global $CFG, $DB;
2385
2386 $allnames = get_all_user_name_fields(true, 'u');
2387 if ($log->action == "add post") {
2388
2389 return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2390 FROM {forum_discussions} d,
2391 {forum_posts} p,
2392 {forum} f,
2393 {user} u
2394 WHERE p.id = ?
2395 AND d.id = p.discussion
2396 AND p.userid = u.id
2397 AND u.deleted <> '1'
2398 AND f.id = d.forum", array($log->info));
2399
2400
2401 } else if ($log->action == "add discussion") {
2402
2403 return $DB->get_record_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid, $allnames, u.email, u.picture
2404 FROM {forum_discussions} d,
2405 {forum_posts} p,
2406 {forum} f,
2407 {user} u
2408 WHERE d.id = ?
2409 AND d.firstpost = p.id
2410 AND p.userid = u.id
2411 AND u.deleted <> '1'
2412 AND f.id = d.forum", array($log->info));
2413 }
2414 return NULL;
2415 }
2416
2417 /**
2418 * Given a discussion id, return the first post from the discussion
2419 *
2420 * @global object
2421 * @global object
2422 * @param int $dicsussionid
2423 * @return array
2424 */
2425 function forum_get_firstpost_from_discussion($discussionid) {
2426 global $CFG, $DB;
2427
2428 return $DB->get_record_sql("SELECT p.*
2429 FROM {forum_discussions} d,
2430 {forum_posts} p
2431 WHERE d.id = ?
2432 AND d.firstpost = p.id ", array($discussionid));
2433 }
2434
2435 /**
2436 * Returns an array of counts of replies to each discussion
2437 *
2438 * @global object
2439 * @global object
2440 * @param int $forumid
2441 * @param string $forumsort
2442 * @param int $limit
2443 * @param int $page
2444 * @param int $perpage
2445 * @return array
2446 */
2447 function forum_count_discussion_replies($forumid, $forumsort="", $limit=-1, $page=-1, $perpage=0) {
2448 global $CFG, $DB;
2449
2450 if ($limit > 0) {
2451 $limitfrom = 0;
2452 $limitnum = $limit;
2453 } else if ($page != -1) {
2454 $limitfrom = $page*$perpage;
2455 $limitnum = $perpage;
2456 } else {
2457 $limitfrom = 0;
2458 $limitnum = 0;
2459 }
2460
2461 if ($forumsort == "") {
2462 $orderby = "";
2463 $groupby = "";
2464
2465 } else {
2466 $orderby = "ORDER BY $forumsort";
2467 $groupby = ", ".strtolower($forumsort);
2468 $groupby = str_replace('desc', '', $groupby);
2469 $groupby = str_replace('asc', '', $groupby);
2470 }
2471
2472 if (($limitfrom == 0 and $limitnum == 0) or $forumsort == "") {
2473 $sql = "SELECT p.discussion, COUNT(p.id) AS replies, MAX(p.id) AS lastpostid
2474 FROM {forum_posts} p
2475 JOIN {forum_discussions} d ON p.discussion = d.id
2476 WHERE p.parent > 0 AND d.forum = ?
2477 GROUP BY p.discussion";
2478 return $DB->get_records_sql($sql, array($forumid));
2479
2480 } else {
2481 $sql = "SELECT p.discussion, (COUNT(p.id) - 1) AS replies, MAX(p.id) AS lastpostid
2482 FROM {forum_posts} p
2483 JOIN {forum_discussions} d ON p.discussion = d.id
2484 WHERE d.forum = ?
2485 GROUP BY p.discussion $groupby
2486 $orderby";
2487 return $DB->get_records_sql("SELECT * FROM ($sql) sq", array($forumid), $limitfrom, $limitnum);
2488 }
2489 }
2490
2491 /**
2492 * @global object
2493 * @global object
2494 * @global object
2495 * @staticvar array $cache
2496 * @param object $forum
2497 * @param object $cm
2498 * @param object $course
2499 * @return mixed
2500 */
2501 function forum_count_discussions($forum, $cm, $course) {
2502 global $CFG, $DB, $USER;
2503
2504 static $cache = array();
2505
2506 $now = round(time(), -2); // db cache friendliness
2507
2508 $params = array($course->id);
2509
2510 if (!isset($cache[$course->id])) {
2511 if (!empty($CFG->forum_enabletimedposts)) {
2512 $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
2513 $params[] = $now;
2514 $params[] = $now;
2515 } else {
2516 $timedsql = "";
2517 }
2518
2519 $sql = "SELECT f.id, COUNT(d.id) as dcount
2520 FROM {forum} f
2521 JOIN {forum_discussions} d ON d.forum = f.id
2522 WHERE f.course = ?
2523 $timedsql
2524 GROUP BY f.id";
2525
2526 if ($counts = $DB->get_records_sql($sql, $params)) {
2527 foreach ($counts as $count) {
2528 $counts[$count->id] = $count->dcount;
2529 }
2530 $cache[$course->id] = $counts;
2531 } else {
2532 $cache[$course->id] = array();
2533 }
2534 }
2535
2536 if (empty($cache[$course->id][$forum->id])) {
2537 return 0;
2538 }
2539
2540 $groupmode = groups_get_activity_groupmode($cm, $course);
2541
2542 if ($groupmode != SEPARATEGROUPS) {
2543 return $cache[$course->id][$forum->id];
2544 }
2545
2546 if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
2547 return $cache[$course->id][$forum->id];
2548 }
2549
2550 require_once($CFG->dirroot.'/course/lib.php');
2551
2552 $modinfo = get_fast_modinfo($course);
2553
2554 $mygroups = $modinfo->get_groups($cm->groupingid);
2555
2556 // add all groups posts
2557 $mygroups[-1] = -1;
2558
2559 list($mygroups_sql, $params) = $DB->get_in_or_equal($mygroups);
2560 $params[] = $forum->id;
2561
2562 if (!empty($CFG->forum_enabletimedposts)) {
2563 $timedsql = "AND d.timestart < $now AND (d.timeend = 0 OR d.timeend > $now)";
2564 $params[] = $now;
2565 $params[] = $now;
2566 } else {
2567 $timedsql = "";
2568 }
2569
2570 $sql = "SELECT COUNT(d.id)
2571 FROM {forum_discussions} d
2572 WHERE d.groupid $mygroups_sql AND d.forum = ?
2573 $timedsql";
2574
2575 return $DB->get_field_sql($sql, $params);
2576 }
2577
2578 /**
2579 * Get all discussions in a forum
2580 *
2581 * @global object
2582 * @global object
2583 * @global object
2584 * @uses CONTEXT_MODULE
2585 * @uses VISIBLEGROUPS
2586 * @param object $cm
2587 * @param string $forumsort
2588 * @param bool $fullpost
2589 * @param int $unused
2590 * @param int $limit
2591 * @param bool $userlastmodified
2592 * @param int $page
2593 * @param int $perpage
2594 * @return array
2595 */
2596 function forum_get_discussions($cm, $forumsort="d.timemodified DESC", $fullpost=true, $unused=-1, $limit=-1, $userlastmodified=false, $page=-1, $perpage=0) {
2597 global $CFG, $DB, $USER;
2598
2599 $timelimit = '';
2600
2601 $now = round(time(), -2);
2602 $params = array($cm->instance);
2603
2604 $modcontext = context_module::instance($cm->id);
2605
2606 if (!has_capability('mod/forum:viewdiscussion', $modcontext)) { /// User must have perms to view discussions
2607 return array();
2608 }
2609
2610 if (!empty($CFG->forum_enabletimedposts)) { /// Users must fulfill timed posts
2611
2612 if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2613 $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2614 $params[] = $now;
2615 $params[] = $now;
2616 if (isloggedin()) {
2617 $timelimit .= " OR d.userid = ?";
2618 $params[] = $USER->id;
2619 }
2620 $timelimit .= ")";
2621 }
2622 }
2623
2624 if ($limit > 0) {
2625 $limitfrom = 0;
2626 $limitnum = $limit;
2627 } else if ($page != -1) {
2628 $limitfrom = $page*$perpage;
2629 $limitnum = $perpage;
2630 } else {
2631 $limitfrom = 0;
2632 $limitnum = 0;
2633 }
2634
2635 $groupmode = groups_get_activity_groupmode($cm);
2636 $currentgroup = groups_get_activity_group($cm);
2637
2638 if ($groupmode) {
2639 if (empty($modcontext)) {
2640 $modcontext = context_module::instance($cm->id);
2641 }
2642
2643 if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2644 if ($currentgroup) {
2645 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2646 $params[] = $currentgroup;
2647 } else {
2648 $groupselect = "";
2649 }
2650
2651 } else {
2652 //seprate groups without access all
2653 if ($currentgroup) {
2654 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2655 $params[] = $currentgroup;
2656 } else {
2657 $groupselect = "AND d.groupid = -1";
2658 }
2659 }
2660 } else {
2661 $groupselect = "";
2662 }
2663
2664
2665 if (empty($forumsort)) {
2666 $forumsort = "d.timemodified DESC";
2667 }
2668 if (empty($fullpost)) {
2669 $postdata = "p.id,p.subject,p.modified,p.discussion,p.userid";
2670 } else {
2671 $postdata = "p.*";
2672 }
2673
2674 if (empty($userlastmodified)) { // We don't need to know this
2675 $umfields = "";
2676 $umtable = "";
2677 } else {
2678 $umfields = ', ' . get_all_user_name_fields(true, 'um', null, 'um');
2679 $umtable = " LEFT JOIN {user} um ON (d.usermodified = um.id)";
2680 }
2681
2682 $allnames = get_all_user_name_fields(true, 'u');
2683 $sql = "SELECT $postdata, d.name, d.timemodified, d.usermodified, d.groupid, d.timestart, d.timeend, $allnames,
2684 u.email, u.picture, u.imagealt $umfields
2685 FROM {forum_discussions} d
2686 JOIN {forum_posts} p ON p.discussion = d.id
2687 JOIN {user} u ON p.userid = u.id
2688 $umtable
2689 WHERE d.forum = ? AND p.parent = 0
2690 $timelimit $groupselect
2691 ORDER BY $forumsort";
2692 return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
2693 }
2694
2695 /**
2696 * Gets the neighbours (previous and next) of a discussion.
2697 *
2698 * The calculation is based on the timemodified of the discussion and does not handle
2699 * the neighbours having an identical timemodified. The reason is that we do not have any
2700 * other mean to sort the records, e.g. we cannot use IDs as a greater ID can have a lower
2701 * timemodified.
2702 *
2703 * Please note that this does not check whether or not the discussion passed is accessible
2704 * by the user, it simply uses it as a reference to find the neighbours. On the other hand,
2705 * the returned neighbours are checked and are accessible to the current user.
2706 *
2707 * @param object $cm The CM record.
2708 * @param object $discussion The discussion record.
2709 * @return array That always contains the keys 'prev' and 'next'. When there is a result
2710 * they contain the record with minimal information such as 'id' and 'name'.
2711 * When the neighbour is not found the value is false.
2712 */
2713 function forum_get_discussion_neighbours($cm, $discussion) {
2714 global $CFG, $DB, $USER;
2715
2716 if ($cm->instance != $discussion->forum) {
2717 throw new coding_exception('Discussion is not part of the same forum.');
2718 }
2719
2720 $neighbours = array('prev' => false, 'next' => false);
2721 $now = round(time(), -2);
2722 $params = array();
2723
2724 $modcontext = context_module::instance($cm->id);
2725 $groupmode = groups_get_activity_groupmode($cm);
2726 $currentgroup = groups_get_activity_group($cm);
2727
2728 // Users must fulfill timed posts.
2729 $timelimit = '';
2730 if (!empty($CFG->forum_enabletimedposts)) {
2731 if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2732 $timelimit = ' AND ((d.timestart <= :tltimestart AND (d.timeend = 0 OR d.timeend > :tltimeend))';
2733 $params['tltimestart'] = $now;
2734 $params['tltimeend'] = $now;
2735 if (isloggedin()) {
2736 $timelimit .= ' OR d.userid = :tluserid';
2737 $params['tluserid'] = $USER->id;
2738 }
2739 $timelimit .= ')';
2740 }
2741 }
2742
2743 // Limiting to posts accessible according to groups.
2744 $groupselect = '';
2745 if ($groupmode) {
2746 if ($groupmode == VISIBLEGROUPS || has_capability('moodle/site:accessallgroups', $modcontext)) {
2747 if ($currentgroup) {
2748 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2749 $params['groupid'] = $currentgroup;
2750 }
2751 } else {
2752 if ($currentgroup) {
2753 $groupselect = 'AND (d.groupid = :groupid OR d.groupid = -1)';
2754 $params['groupid'] = $currentgroup;
2755 } else {
2756 $groupselect = 'AND d.groupid = -1';
2757 }
2758 }
2759 }
2760
2761 $params['forumid'] = $cm->instance;
2762 $params['discid'] = $discussion->id;
2763 $params['disctimemodified'] = $discussion->timemodified;
2764
2765 $sql = "SELECT d.id, d.name, d.timemodified, d.groupid, d.timestart, d.timeend
2766 FROM {forum_discussions} d
2767 WHERE d.forum = :forumid
2768 AND d.id <> :discid
2769 $timelimit
2770 $groupselect";
2771
2772 $prevsql = $sql . " AND d.timemodified < :disctimemodified
2773 ORDER BY d.timemodified DESC";
2774
2775 $nextsql = $sql . " AND d.timemodified > :disctimemodified
2776 ORDER BY d.timemodified ASC";
2777
2778 $neighbours['prev'] = $DB->get_record_sql($prevsql, $params, IGNORE_MULTIPLE);
2779 $neighbours['next'] = $DB->get_record_sql($nextsql, $params, IGNORE_MULTIPLE);
2780
2781 return $neighbours;
2782 }
2783
2784 /**
2785 *
2786 * @global object
2787 * @global object
2788 * @global object
2789 * @uses CONTEXT_MODULE
2790 * @uses VISIBLEGROUPS
2791 * @param object $cm
2792 * @return array
2793 */
2794 function forum_get_discussions_unread($cm) {
2795 global $CFG, $DB, $USER;
2796
2797 $now = round(time(), -2);
2798 $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2799
2800 $params = array();
2801 $groupmode = groups_get_activity_groupmode($cm);
2802 $currentgroup = groups_get_activity_group($cm);
2803
2804 if ($groupmode) {
2805 $modcontext = context_module::instance($cm->id);
2806
2807 if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2808 if ($currentgroup) {
2809 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2810 $params['currentgroup'] = $currentgroup;
2811 } else {
2812 $groupselect = "";
2813 }
2814
2815 } else {
2816 //separate groups without access all
2817 if ($currentgroup) {
2818 $groupselect = "AND (d.groupid = :currentgroup OR d.groupid = -1)";
2819 $params['currentgroup'] = $currentgroup;
2820 } else {
2821 $groupselect = "AND d.groupid = -1";
2822 }
2823 }
2824 } else {
2825 $groupselect = "";
2826 }
2827
2828 if (!empty($CFG->forum_enabletimedposts)) {
2829 $timedsql = "AND d.timestart < :now1 AND (d.timeend = 0 OR d.timeend > :now2)";
2830 $params['now1'] = $now;
2831 $params['now2'] = $now;
2832 } else {
2833 $timedsql = "";
2834 }
2835
2836 $sql = "SELECT d.id, COUNT(p.id) AS unread
2837 FROM {forum_discussions} d
2838 JOIN {forum_posts} p ON p.discussion = d.id
2839 LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = $USER->id)
2840 WHERE d.forum = {$cm->instance}
2841 AND p.modified >= :cutoffdate AND r.id is NULL
2842 $groupselect
2843 $timedsql
2844 GROUP BY d.id";
2845 $params['cutoffdate'] = $cutoffdate;
2846
2847 if ($unreads = $DB->get_records_sql($sql, $params)) {
2848 foreach ($unreads as $unread) {
2849 $unreads[$unread->id] = $unread->unread;
2850 }
2851 return $unreads;
2852 } else {
2853 return array();
2854 }
2855 }
2856
2857 /**
2858 * @global object
2859 * @global object
2860 * @global object
2861 * @uses CONEXT_MODULE
2862 * @uses VISIBLEGROUPS
2863 * @param object $cm
2864 * @return array
2865 */
2866 function forum_get_discussions_count($cm) {
2867 global $CFG, $DB, $USER;
2868
2869 $now = round(time(), -2);
2870 $params = array($cm->instance);
2871 $groupmode = groups_get_activity_groupmode($cm);
2872 $currentgroup = groups_get_activity_group($cm);
2873
2874 if ($groupmode) {
2875 $modcontext = context_module::instance($cm->id);
2876
2877 if ($groupmode == VISIBLEGROUPS or has_capability('moodle/site:accessallgroups', $modcontext)) {
2878 if ($currentgroup) {
2879 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2880 $params[] = $currentgroup;
2881 } else {
2882 $groupselect = "";
2883 }
2884
2885 } else {
2886 //seprate groups without access all
2887 if ($currentgroup) {
2888 $groupselect = "AND (d.groupid = ? OR d.groupid = -1)";
2889 $params[] = $currentgroup;
2890 } else {
2891 $groupselect = "AND d.groupid = -1";
2892 }
2893 }
2894 } else {
2895 $groupselect = "";
2896 }
2897
2898 $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
2899
2900 $timelimit = "";
2901
2902 if (!empty($CFG->forum_enabletimedposts)) {
2903
2904 $modcontext = context_module::instance($cm->id);
2905
2906 if (!has_capability('mod/forum:viewhiddentimedposts', $modcontext)) {
2907 $timelimit = " AND ((d.timestart <= ? AND (d.timeend = 0 OR d.timeend > ?))";
2908 $params[] = $now;
2909 $params[] = $now;
2910 if (isloggedin()) {
2911 $timelimit .= " OR d.userid = ?";
2912 $params[] = $USER->id;
2913 }
2914 $timelimit .= ")";
2915 }
2916 }
2917
2918 $sql = "SELECT COUNT(d.id)
2919 FROM {forum_discussions} d
2920 JOIN {forum_posts} p ON p.discussion = d.id
2921 WHERE d.forum = ? AND p.parent = 0
2922 $groupselect $timelimit";
2923
2924 return $DB->get_field_sql($sql, $params);
2925 }
2926
2927
2928 // OTHER FUNCTIONS ///////////////////////////////////////////////////////////
2929
2930
2931 /**
2932 * @global object
2933 * @global object
2934 * @param int $courseid
2935 * @param string $type
2936 */
2937 function forum_get_course_forum($courseid, $type) {
2938 // How to set up special 1-per-course forums
2939 global $CFG, $DB, $OUTPUT, $USER;
2940
2941 if ($forums = $DB->get_records_select("forum", "course = ? AND type = ?", array($courseid, $type), "id ASC")) {
2942 // There should always only be ONE, but with the right combination of
2943 // errors there might be more. In this case, just return the oldest one (lowest ID).
2944 foreach ($forums as $forum) {
2945 return $forum; // ie the first one
2946 }
2947 }
2948
2949 // Doesn't exist, so create one now.
2950 $forum = new stdClass();
2951 $forum->course = $courseid;
2952 $forum->type = "$type";
2953 if (!empty($USER->htmleditor)) {
2954 $forum->introformat = $USER->htmleditor;
2955 }
2956 switch ($forum->type) {
2957 case "news":
2958 $forum->name = get_string("namenews", "forum");
2959 $forum->intro = get_string("intronews", "forum");
2960 $forum->forcesubscribe = FORUM_FORCESUBSCRIBE;
2961 $forum->assessed = 0;
2962 if ($courseid == SITEID) {
2963 $forum->name = get_string("sitenews");
2964 $forum->forcesubscribe = 0;
2965 }
2966 break;
2967 case "social":
2968 $forum->name = get_string("namesocial", "forum");
2969 $forum->intro = get_string("introsocial", "forum");
2970 $forum->assessed = 0;
2971 $forum->forcesubscribe = 0;
2972 break;
2973 case "blog":
2974 $forum->name = get_string('blogforum', 'forum');
2975 $forum->intro = get_string('introblog', 'forum');
2976 $forum->assessed = 0;
2977 $forum->forcesubscribe = 0;
2978 break;
2979 default:
2980 echo $OUTPUT->notification("That forum type doesn't exist!");
2981 return false;
2982 break;
2983 }
2984
2985 $forum->timemodified = time();
2986 $forum->id = $DB->insert_record("forum", $forum);
2987
2988 if (! $module = $DB->get_record("modules", array("name" => "forum"))) {
2989 echo $OUTPUT->notification("Could not find forum module!!");
2990 return false;
2991 }
2992 $mod = new stdClass();
2993 $mod->course = $courseid;
2994 $mod->module = $module->id;
2995 $mod->instance = $forum->id;
2996 $mod->section = 0;
2997 include_once("$CFG->dirroot/course/lib.php");
2998 if (! $mod->coursemodule = add_course_module($mod) ) {
2999 echo $OUTPUT->notification("Could not add a new course module to the course '" . $courseid . "'");
3000 return false;
3001 }
3002 $sectionid = course_add_cm_to_section($courseid, $mod->coursemodule, 0);
3003 return $DB->get_record("forum", array("id" => "$forum->id"));
3004 }
3005
3006
3007 /**
3008 * Given the data about a posting, builds up the HTML to display it and
3009 * returns the HTML in a string. This is designed for sending via HTML email.
3010 *
3011 * @global object
3012 * @param object $course
3013 * @param object $cm
3014 * @param object $forum
3015 * @param object $discussion
3016 * @param object $post
3017 * @param object $userform
3018 * @param object $userto
3019 * @param bool $ownpost
3020 * @param bool $reply
3021 * @param bool $link
3022 * @param bool $rate
3023 * @param string $footer
3024 * @return string
3025 */
3026 function forum_make_mail_post($course, $cm, $forum, $discussion, $post, $userfrom, $userto,
3027 $ownpost=false, $reply=false, $link=false, $rate=false, $footer="") {
3028
3029 global $CFG, $OUTPUT;
3030
3031 $modcontext = context_module::instance($cm->id);
3032
3033 if (!isset($userto->viewfullnames[$forum->id])) {
3034 $viewfullnames = has_capability('moodle/site:viewfullnames', $modcontext, $userto->id);
3035 } else {
3036 $viewfullnames = $userto->viewfullnames[$forum->id];
3037 }
3038
3039 // add absolute file links
3040 $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
3041
3042 // format the post body
3043 $options = new stdClass();
3044 $options->para = true;
3045 $formattedtext = format_text($post->message, $post->messageformat, $options, $course->id);
3046
3047 $output = '<table border="0" cellpadding="3" cellspacing="0" class="forumpost">';
3048
3049 $output .= '<tr class="header"><td width="35" valign="top" class="picture left">';
3050 $output .= $OUTPUT->user_picture($userfrom, array('courseid'=>$course->id));
3051 $output .= '</td>';
3052
3053 if ($post->parent) {
3054 $output .= '<td class="topic">';
3055 } else {
3056 $output .= '<td class="topic starter">';
3057 }
3058 $output .= '<div class="subject">'.format_string($post->subject).'</div>';
3059
3060 $fullname = fullname($userfrom, $viewfullnames);
3061 $by = new stdClass();
3062 $by->name = '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$userfrom->id.'&amp;course='.$course->id.'">'.$fullname.'</a>';
3063 $by->date = userdate($post->modified, '', $userto->timezone);
3064 $output .= '<div class="author">'.get_string('bynameondate', 'forum', $by).'</div>';
3065
3066 $output .= '</td></tr>';
3067
3068 $output .= '<tr><td class="left side" valign="top">';
3069
3070 if (isset($userfrom->groups)) {
3071 $groups = $userfrom->groups[$forum->id];
3072 } else {
3073 $groups = groups_get_all_groups($course->id, $userfrom->id, $cm->groupingid);
3074 }
3075
3076 if ($groups) {
3077 $output .= print_group_picture($groups, $course->id, false, true, true);
3078 } else {
3079 $output .= '&nbsp;';
3080 }
3081
3082 $output .= '</td><td class="content">';
3083
3084 $attachments = forum_print_attachments($post, $cm, 'html');
3085 if ($attachments !== '') {
3086 $output .= '<div class="attachments">';
3087 $output .= $attachments;
3088 $output .= '</div>';
3089 }
3090
3091 $output .= $formattedtext;
3092
3093 // Commands
3094 $commands = array();
3095
3096 if ($post->parent) {
3097 $commands[] = '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.
3098 $post->discussion.'&amp;parent='.$post->parent.'">'.get_string('parent', 'forum').'</a>';
3099 }
3100
3101 if ($reply) {
3102 $commands[] = '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/post.php?reply='.$post->id.'">'.
3103 get_string('reply', 'forum').'</a>';
3104 }
3105
3106 $output .= '<div class="commands">';
3107 $output .= implode(' | ', $commands);
3108 $output .= '</div>';
3109
3110 // Context link to post if required
3111 if ($link) {
3112 $output .= '<div class="link">';
3113 $output .= '<a target="_blank" href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'#p'.$post->id.'">'.
3114 get_string('postincontext', 'forum').'</a>';
3115 $output .= '</div>';
3116 }
3117
3118 if ($footer) {
3119 $output .= '<div class="footer">'.$footer.'</div>';
3120 }
3121 $output .= '</td></tr></table>'."\n\n";
3122
3123 return $output;
3124 }
3125
3126 /**
3127 * Print a forum post
3128 *
3129 * @global object
3130 * @global object
3131 * @uses FORUM_MODE_THREADED
3132 * @uses PORTFOLIO_FORMAT_PLAINHTML
3133 * @uses PORTFOLIO_FORMAT_FILE
3134 * @uses PORTFOLIO_FORMAT_RICHHTML
3135 * @uses PORTFOLIO_ADD_TEXT_LINK
3136 * @uses CONTEXT_MODULE
3137 * @param object $post The post to print.
3138 * @param object $discussion
3139 * @param object $forum
3140 * @param object $cm
3141 * @param object $course
3142 * @param boolean $ownpost Whether this post belongs to the current user.
3143 * @param boolean $reply Whether to print a 'reply' link at the bottom of the message.
3144 * @param boolean $link Just print a shortened version of the post as a link to the full post.
3145 * @param string $footer Extra stuff to print after the message.
3146 * @param string $highlight Space-separated list of terms to highlight.
3147 * @param int $post_read true, false or -99. If we already know whether this user
3148 * has read this post, pass that in, otherwise, pass in -99, and this
3149 * function will work it out.
3150 * @param boolean $dummyifcantsee When forum_user_can_see_post says that
3151 * the current user can't see this post, if this argument is true
3152 * (the default) then print a dummy 'you can't see this post' post.
3153 * If false, don't output anything at all.
3154 * @param bool|null $istracked
3155 * @return void
3156 */
3157 function forum_print_post($post, $discussion, $forum, &$cm, $course, $ownpost=false, $reply=false, $link=false,
3158 $footer="", $highlight="", $postisread=null, $dummyifcantsee=true, $istracked=null, $return=false) {
3159 global $USER, $CFG, $OUTPUT;
3160
3161 require_once($CFG->libdir . '/filelib.php');
3162
3163 // String cache
3164 static $str;
3165
3166 $modcontext = context_module::instance($cm->id);
3167
3168 $post->course = $course->id;
3169 $post->forum = $forum->id;
3170 $post->message = file_rewrite_pluginfile_urls($post->message, 'pluginfile.php', $modcontext->id, 'mod_forum', 'post', $post->id);
3171 if (!empty($CFG->enableplagiarism)) {
3172 require_once($CFG->libdir.'/plagiarismlib.php');
3173 $post->message .= plagiarism_get_links(array('userid' => $post->userid,
3174 'content' => $post->message,
3175 'cmid' => $cm->id,
3176 'course' => $post->course,
3177 'forum' => $post->forum));
3178 }
3179
3180 // caching
3181 if (!isset($cm->cache)) {
3182 $cm->cache = new stdClass;
3183 }
3184
3185 if (!isset($cm->cache->caps)) {
3186 $cm->cache->caps = array();
3187 $cm->cache->caps['mod/forum:viewdiscussion'] = has_capability('mod/forum:viewdiscussion', $modcontext);
3188 $cm->cache->caps['moodle/site:viewfullnames'] = has_capability('moodle/site:viewfullnames', $modcontext);
3189 $cm->cache->caps['mod/forum:editanypost'] = has_capability('mod/forum:editanypost', $modcontext);
3190 $cm->cache->caps['mod/forum:splitdiscussions'] = has_capability('mod/forum:splitdiscussions', $modcontext);
3191 $cm->cache->caps['mod/forum:deleteownpost'] = has_capability('mod/forum:deleteownpost', $modcontext);
3192 $cm->cache->caps['mod/forum:deleteanypost'] = has_capability('mod/forum:deleteanypost', $modcontext);
3193 $cm->cache->caps['mod/forum:viewanyrating'] = has_capability('mod/forum:viewanyrating', $modcontext);
3194 $cm->cache->caps['mod/forum:exportpost'] = has_capability('mod/forum:exportpost', $modcontext);
3195 $cm->cache->caps['mod/forum:exportownpost'] = has_capability('mod/forum:exportownpost', $modcontext);
3196 }
3197
3198 if (!isset($cm->uservisible)) {
3199 $cm->uservisible = \core_availability\info_module::is_user_visible($cm, 0, false);
3200 }
3201
3202 if ($istracked && is_null($postisread)) {
3203 $postisread = forum_tp_is_post_read($USER->id, $post);
3204 }
3205
3206 if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
3207 $output = '';
3208 if (!$dummyifcantsee) {
3209 if ($return) {
3210 return $output;
3211 }
3212 echo $output;
3213 return;
3214 }
3215 $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3216 $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix',
3217 'role' => 'region',
3218 'aria-label' => get_string('hiddenforumpost', 'forum')));
3219 $output .= html_writer::start_tag('div', array('class'=>'row header'));
3220 $output .= html_writer::tag('div', '', array('class'=>'left picture')); // Picture
3221 if ($post->parent) {
3222 $output .= html_writer::start_tag('div', array('class'=>'topic'));
3223 } else {
3224 $output .= html_writer::start_tag('div', array('class'=>'topic starter'));
3225 }
3226 $output .= html_writer::tag('div', get_string('forumsubjecthidden','forum'), array('class' => 'subject',
3227 'role' => 'header')); // Subject.
3228 $output .= html_writer::tag('div', get_string('forumauthorhidden', 'forum'), array('class' => 'author',
3229 'role' => 'header')); // Author.
3230 $output .= html_writer::end_tag('div');
3231 $output .= html_writer::end_tag('div'); // row
3232 $output .= html_writer::start_tag('div', array('class'=>'row'));
3233 $output .= html_writer::tag('div', '&nbsp;', array('class'=>'left side')); // Groups
3234 $output .= html_writer::tag('div', get_string('forumbodyhidden','forum'), array('class'=>'content')); // Content
3235 $output .= html_writer::end_tag('div'); // row
3236 $output .= html_writer::end_tag('div'); // forumpost
3237
3238 if ($return) {
3239 return $output;
3240 }
3241 echo $output;
3242 return;
3243 }
3244
3245 if (empty($str)) {
3246 $str = new stdClass;
3247 $str->edit = get_string('edit', 'forum');
3248 $str->delete = get_string('delete', 'forum');
3249 $str->reply = get_string('reply', 'forum');
3250 $str->parent = get_string('parent', 'forum');
3251 $str->pruneheading = get_string('pruneheading', 'forum');
3252 $str->prune = get_string('prune', 'forum');
3253 $str->displaymode = get_user_preferences('forum_displaymode', $CFG->forum_displaymode);
3254 $str->markread = get_string('markread', 'forum');
3255 $str->markunread = get_string('markunread', 'forum');
3256 }
3257
3258 $discussionlink = new moodle_url('/mod/forum/discuss.php', array('d'=>$post->discussion));
3259
3260 // Build an object that represents the posting user
3261 $postuser = new stdClass;
3262 $postuserfields = explode(',', user_picture::fields());
3263 $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
3264 $postuser->id = $post->userid;
3265 $postuser->fullname = fullname($postuser, $cm->cache->caps['moodle/site:viewfullnames']);
3266 $postuser->profilelink = new moodle_url('/user/view.php', array('id'=>$post->userid, 'course'=>$course->id));
3267
3268 // Prepare the groups the posting user belongs to
3269 if (isset($cm->cache->usersgroups)) {
3270 $groups = array();
3271 if (isset($cm->cache->usersgroups[$post->userid])) {
3272 foreach ($cm->cache->usersgroups[$post->userid] as $gid) {
3273 $groups[$gid] = $cm->cache->groups[$gid];
3274 }
3275 }
3276 } else {
3277 $groups = groups_get_all_groups($course->id, $post->userid, $cm->groupingid);
3278 }
3279
3280 // Prepare the attachements for the post, files then images
3281 list($attachments, $attachedimages) = forum_print_attachments($post, $cm, 'separateimages');
3282
3283 // Determine if we need to shorten this post
3284 $shortenpost = ($link && (strlen(strip_tags($post->message)) > $CFG->forum_longpost));
3285
3286
3287 // Prepare an array of commands
3288 $commands = array();
3289
3290 // SPECIAL CASE: The front page can display a news item post to non-logged in users.
3291 // Don't display the mark read / unread controls in this case.
3292 if ($istracked && $CFG->forum_usermarksread && isloggedin()) {
3293 $url = new moodle_url($discussionlink, array('postid'=>$post->id, 'mark'=>'unread'));
3294 $text = $str->markunread;
3295 if (!$postisread) {
3296 $url->param('mark', 'read');
3297 $text = $str->markread;
3298 }
3299 if ($str->displaymode == FORUM_MODE_THREADED) {
3300 $url->param('parent', $post->parent);
3301 } else {
3302 $url->set_anchor('p'.$post->id);
3303 }
3304 $commands[] = array('url'=>$url, 'text'=>$text);
3305 }
3306
3307 // Zoom in to the parent specifically
3308 if ($post->parent) {
3309 $url = new moodle_url($discussionlink);
3310 if ($str->displaymode == FORUM_MODE_THREADED) {
3311 $url->param('parent', $post->parent);
3312 } else {
3313 $url->set_anchor('p'.$post->parent);
3314 }
3315 $commands[] = array('url'=>$url, 'text'=>$str->parent);
3316 }
3317
3318 // Hack for allow to edit news posts those are not displayed yet until they are displayed
3319 $age = time() - $post->created;
3320 if (!$post->parent && $forum->type == 'news' && $discussion->timestart > time()) {
3321 $age = 0;
3322 }
3323
3324 if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3325 if (has_capability('moodle/course:manageactivities', $modcontext)) {
3326 // The first post in single simple is the forum description.
3327 $commands[] = array('url'=>new moodle_url('/course/modedit.php', array('update'=>$cm->id, 'sesskey'=>sesskey(), 'return'=>1)), 'text'=>$str->edit);
3328 }
3329 } else if (($ownpost && $age < $CFG->maxeditingtime) || $cm->cache->caps['mod/forum:editanypost']) {
3330 $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('edit'=>$post->id)), 'text'=>$str->edit);
3331 }
3332
3333 if ($cm->cache->caps['mod/forum:splitdiscussions'] && $post->parent && $forum->type != 'single') {
3334 $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('prune'=>$post->id)), 'text'=>$str->prune, 'title'=>$str->pruneheading);
3335 }
3336
3337 if ($forum->type == 'single' and $discussion->firstpost == $post->id) {
3338 // Do not allow deleting of first post in single simple type.
3339 } else if (($ownpost && $age < $CFG->maxeditingtime && $cm->cache->caps['mod/forum:deleteownpost']) || $cm->cache->caps['mod/forum:deleteanypost']) {
3340 $commands[] = array('url'=>new moodle_url('/mod/forum/post.php', array('delete'=>$post->id)), 'text'=>$str->delete);
3341 }
3342
3343 if ($reply) {
3344 $commands[] = array('url'=>new moodle_url('/mod/forum/post.php#mformforum', array('reply'=>$post->id)), 'text'=>$str->reply);
3345 }
3346
3347 if ($CFG->enableportfolios && ($cm->cache->caps['mod/forum:exportpost'] || ($ownpost && $cm->cache->caps['mod/forum:exportownpost']))) {
3348 $p = array('postid' => $post->id);
3349 require_once($CFG->libdir.'/portfoliolib.php');
3350 $button = new portfolio_add_button();
3351 $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id), 'mod_forum');
3352 if (empty($attachments)) {
3353 $button->set_formats(PORTFOLIO_FORMAT_PLAINHTML);
3354 } else {
3355 $button->set_formats(PORTFOLIO_FORMAT_RICHHTML);
3356 }
3357
3358 $porfoliohtml = $button->to_html(PORTFOLIO_ADD_TEXT_LINK);
3359 if (!empty($porfoliohtml)) {
3360 $commands[] = $porfoliohtml;
3361 }
3362 }
3363 // Finished building commands
3364
3365
3366 // Begin output
3367
3368 $output = '';
3369
3370 if ($istracked) {
3371 if ($postisread) {
3372 $forumpostclass = ' read';
3373 } else {
3374 $forumpostclass = ' unread';
3375 $output .= html_writer::tag('a', '', array('name'=>'unread'));
3376 }
3377 } else {
3378 // ignore trackign status if not tracked or tracked param missing
3379 $forumpostclass = '';
3380 }
3381
3382 $topicclass = '';
3383 if (empty($post->parent)) {
3384 $topicclass = ' firstpost starter';
3385 }
3386
3387 $postbyuser = new stdClass;
3388 $postbyuser->post = $post->subject;
3389 $postbyuser->user = $postuser->fullname;
3390 $discussionbyuser = get_string('postbyuser', 'forum', $postbyuser);
3391 $output .= html_writer::tag('a', '', array('id'=>'p'.$post->id));
3392 $output .= html_writer::start_tag('div', array('class'=>'forumpost clearfix'.$forumpostclass.$topicclass,
3393 'role' => 'region',
3394 'aria-label' => $discussionbyuser));
3395 $output .= html_writer::start_tag('div', array('class'=>'row header clearfix'));
3396 $output .= html_writer::start_tag('div', array('class'=>'left picture'));
3397 $output .= $OUTPUT->user_picture($postuser, array('courseid'=>$course->id));
3398 $output .= html_writer::end_tag('div');
3399
3400
3401 $output .= html_writer::start_tag('div', array('class'=>'topic'.$topicclass));
3402
3403 $postsubject = $post->subject;
3404 if (empty($post->subjectnoformat)) {
3405 $postsubject = format_string($postsubject);
3406 }
3407 $output .= html_writer::tag('div', $postsubject, array('class'=>'subject',
3408 'role' => 'heading',
3409 'aria-level' => '2'));
3410
3411 $by = new stdClass();
3412 $by->name = html_writer::link($postuser->profilelink, $postuser->fullname);
3413 $by->date = userdate($post->modified);
3414 $output .= html_writer::tag('div', get_string('bynameondate', 'forum', $by), array('class'=>'author',
3415 'role' => 'heading',
3416 'aria-level' => '2'));
3417
3418 $output .= html_writer::end_tag('div'); //topic
3419 $output .= html_writer::end_tag('div'); //row
3420
3421 $output .= html_writer::start_tag('div', array('class'=>'row maincontent clearfix'));
3422 $output .= html_writer::start_tag('div', array('class'=>'left'));
3423
3424 $groupoutput = '';
3425 if ($groups) {
3426 $groupoutput = print_group_picture($groups, $course->id, false, true, true);
3427 }
3428 if (empty($groupoutput)) {
3429 $groupoutput = '&nbsp;';
3430 }
3431 $output .= html_writer::tag('div', $groupoutput, array('class'=>'grouppictures'));
3432
3433 $output .= html_writer::end_tag('div'); //left side
3434 $output .= html_writer::start_tag('div', array('class'=>'no-overflow'));
3435 $output .= html_writer::start_tag('div', array('class'=>'content'));
3436
3437 $options = new stdClass;
3438 $options->para = false;
3439 $options->trusted = $post->messagetrust;
3440 $options->context = $modcontext;
3441 if ($shortenpost) {
3442 // Prepare shortened version by filtering the text then shortening it.
3443 $postclass = 'shortenedpost';
3444 $postcontent = format_text($post->message, $post->messageformat, $options);
3445 $postcontent = shorten_text($postcontent, $CFG->forum_shortpost);
3446 $postcontent .= html_writer::link($discussionlink, get_string('readtherest', 'forum'));
3447 $postcontent .= html_writer::tag('div', '('.get_string('numwords', 'moodle', count_words($post->message)).')',
3448 array('class'=>'post-word-count'));
3449 } else {
3450 // Prepare whole post
3451 $postclass = 'fullpost';
3452 $postcontent = format_text($post->message, $post->messageformat, $options, $course->id);
3453 if (!empty($highlight)) {
3454 $postcontent = highlight($highlight, $postcontent);
3455 }
3456 if (!empty($forum->displaywordcount)) {
3457 $postcontent .= html_writer::tag('div', get_string('numwords', 'moodle', count_words($post->message)),
3458 array('class'=>'post-word-count'));
3459 }
3460 $postcontent .= html_writer::tag('div', $attachedimages, array('class'=>'attachedimages'));
3461 }
3462
3463 // Output the post content
3464 $output .= html_writer::tag('div', $postcontent, array('class'=>'posting '.$postclass));
3465 $output .= html_writer::end_tag('div'); // Content
3466 $output .= html_writer::end_tag('div'); // Content mask
3467 $output .= html_writer::end_tag('div'); // Row
3468
3469 $output .= html_writer::start_tag('div', array('class'=>'row side'));
3470 $output .= html_writer::tag('div','&nbsp;', array('class'=>'left'));
3471 $output .= html_writer::start_tag('div', array('class'=>'options clearfix'));
3472
3473 if (!empty($attachments)) {
3474 $output .= html_writer::tag('div', $attachments, array('class' => 'attachments'));
3475 }
3476
3477 // Output ratings
3478 if (!empty($post->rating)) {
3479 $output .= html_writer::tag('div', $OUTPUT->render($post->rating), array('class'=>'forum-post-rating'));
3480 }
3481
3482 // Output the commands
3483 $commandhtml = array();
3484 foreach ($commands as $command) {
3485 if (is_array($command)) {
3486 $commandhtml[] = html_writer::link($command['url'], $command['text']);
3487 } else {
3488 $commandhtml[] = $command;
3489 }
3490 }
3491 $output .= html_writer::tag('div', implode(' | ', $commandhtml), array('class'=>'commands'));
3492
3493 // Output link to post if required
3494 if ($link && forum_user_can_post($forum, $discussion, $USER, $cm, $course, $modcontext)) {
3495 if ($post->replies == 1) {
3496 $replystring = get_string('repliesone', 'forum', $post->replies);
3497 } else {
3498 $replystring = get_string('repliesmany', 'forum', $post->replies);
3499 }
3500
3501 $output .= html_writer::start_tag('div', array('class'=>'link'));
3502 $output .= html_writer::link($discussionlink, get_string('discussthistopic', 'forum'));
3503 $output .= '&nbsp;('.$replystring.')';
3504 $output .= html_writer::end_tag('div'); // link
3505 }
3506
3507 // Output footer if required
3508 if ($footer) {
3509 $output .= html_writer::tag('div', $footer, array('class'=>'footer'));
3510 }
3511
3512 // Close remaining open divs
3513 $output .= html_writer::end_tag('div'); // content
3514 $output .= html_writer::end_tag('div'); // row
3515 $output .= html_writer::end_tag('div'); // forumpost
3516
3517 // Mark the forum post as read if required
3518 if ($istracked && !$CFG->forum_usermarksread && !$postisread) {
3519 forum_tp_mark_post_read($USER->id, $post, $forum->id);
3520 }
3521
3522 if ($return) {
3523 return $output;
3524 }
3525 echo $output;
3526 return;
3527 }
3528
3529 /**
3530 * Return rating related permissions
3531 *
3532 * @param string $options the context id
3533 * @return array an associative array of the user's rating permissions
3534 */
3535 function forum_rating_permissions($contextid, $component, $ratingarea) {
3536 $context = context::instance_by_id($contextid, MUST_EXIST);
3537 if ($component != 'mod_forum' || $ratingarea != 'post') {
3538 // We don't know about this component/ratingarea so just return null to get the
3539 // default restrictive permissions.
3540 return null;
3541 }
3542 return array(
3543 'view' => has_capability('mod/forum:viewrating', $context),
3544 'viewany' => has_capability('mod/forum:viewanyrating', $context),
3545 'viewall' => has_capability('mod/forum:viewallratings', $context),
3546 'rate' => has_capability('mod/forum:rate', $context)
3547 );
3548 }
3549
3550 /**
3551 * Validates a submitted rating
3552 * @param array $params submitted data
3553 * context => object the context in which the rated items exists [required]
3554 * component => The component for this module - should always be mod_forum [required]
3555 * ratingarea => object the context in which the rated items exists [required]
3556 * itemid => int the ID of the object being rated [required]
3557 * scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
3558 * rating => int the submitted rating [required]
3559 * rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
3560 * aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
3561 * @return boolean true if the rating is valid. Will throw rating_exception if not
3562 */
3563 function forum_rating_validate($params) {
3564 global $DB, $USER;
3565
3566 // Check the component is mod_forum
3567 if ($params['component'] != 'mod_forum') {
3568 throw new rating_exception('invalidcomponent');
3569 }
3570
3571 // Check the ratingarea is post (the only rating area in forum)
3572 if ($params['ratingarea'] != 'post') {
3573 throw new rating_exception('invalidratingarea');
3574 }
3575
3576 // Check the rateduserid is not the current user .. you can't rate your own posts
3577 if ($params['rateduserid'] == $USER->id) {
3578 throw new rating_exception('nopermissiontorate');
3579 }
3580
3581 // Fetch all the related records ... we need to do this anyway to call forum_user_can_see_post
3582 $post = $DB->get_record('forum_posts', array('id' => $params['itemid'], 'userid' => $params['rateduserid']), '*', MUST_EXIST);
3583 $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion), '*', MUST_EXIST);
3584 $forum = $DB->get_record('forum', array('id' => $discussion->forum), '*', MUST_EXIST);
3585 $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
3586 $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id , false, MUST_EXIST);
3587 $context = context_module::instance($cm->id);
3588
3589 // Make sure the context provided is the context of the forum
3590 if ($context->id != $params['context']->id) {
3591 throw new rating_exception('invalidcontext');
3592 }
3593
3594 if ($forum->scale != $params['scaleid']) {
3595 //the scale being submitted doesnt match the one in the database
3596 throw new rating_exception('invalidscaleid');
3597 }
3598
3599 // check the item we're rating was created in the assessable time window
3600 if (!empty($forum->assesstimestart) && !empty($forum->assesstimefinish)) {
3601 if ($post->created < $forum->assesstimestart || $post->created > $forum->assesstimefinish) {
3602 throw new rating_exception('notavailable');
3603 }
3604 }
3605
3606 //check that the submitted rating is valid for the scale
3607
3608 // lower limit
3609 if ($params['rating'] < 0 && $params['rating'] != RATING_UNSET_RATING) {
3610 throw new rating_exception('invalidnum');
3611 }
3612
3613 // upper limit
3614 if ($forum->scale < 0) {
3615 //its a custom scale
3616 $scalerecord = $DB->get_record('scale', array('id' => -$forum->scale));
3617 if ($scalerecord) {
3618 $scalearray = explode(',', $scalerecord->scale);
3619 if ($params['rating'] > count($scalearray)) {
3620 throw new rating_exception('invalidnum');
3621 }
3622 } else {
3623 throw new rating_exception('invalidscaleid');
3624 }
3625 } else if ($params['rating'] > $forum->scale) {
3626 //if its numeric and submitted rating is above maximum
3627 throw new rating_exception('invalidnum');
3628 }
3629
3630 // Make sure groups allow this user to see the item they're rating
3631 if ($discussion->groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) { // Groups are being used
3632 if (!groups_group_exists($discussion->groupid)) { // Can't find group
3633 throw new rating_exception('cannotfindgroup');//something is wrong
3634 }
3635
3636 if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
3637 // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
3638 throw new rating_exception('notmemberofgroup');
3639 }
3640 }
3641
3642 // perform some final capability checks
3643 if (!forum_user_can_see_post($forum, $discussion, $post, $USER, $cm)) {
3644 throw new rating_exception('nopermissiontorate');
3645 }
3646
3647 return true;
3648 }
3649
3650
3651 /**
3652 * This function prints the overview of a discussion in the forum listing.
3653 * It needs some discussion information and some post information, these
3654 * happen to be combined for efficiency in the $post parameter by the function
3655 * that calls this one: forum_print_latest_discussions()
3656 *
3657 * @global object
3658 * @global object
3659 * @param object $post The post object (passed by reference for speed).
3660 * @param object $forum The forum object.
3661 * @param int $group Current group.
3662 * @param string $datestring Format to use for the dates.
3663 * @param boolean $cantrack Is tracking enabled for this forum.
3664 * @param boolean $forumtracked Is the user tracking this forum.
3665 * @param boolean $canviewparticipants True if user has the viewparticipants permission for this course
3666 */
3667 function forum_print_discussion_header(&$post, $forum, $group=-1, $datestring="",
3668 $cantrack=true, $forumtracked=true, $canviewparticipants=true, $modcontext=NULL) {
3669
3670 global $COURSE, $USER, $CFG, $OUTPUT;
3671
3672 static $rowcount;
3673 static $strmarkalldread;
3674
3675 if (empty($modcontext)) {
3676 if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
3677 print_error('invalidcoursemodule');
3678 }
3679 $modcontext = context_module::instance($cm->id);
3680 }
3681
3682 if (!isset($rowcount)) {
3683 $rowcount = 0;
3684 $strmarkalldread = get_string('markalldread', 'forum');
3685 } else {
3686 $rowcount = ($rowcount + 1) % 2;
3687 }
3688
3689 $post->subject = format_string($post->subject,true);
3690
3691 echo "\n\n";
3692 echo '<tr class="discussion r'.$rowcount.'">';
3693
3694 // Topic
3695 echo '<td class="topic starter">';
3696 echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">'.$post->subject.'</a>';
3697 echo "</td>\n";
3698
3699 // Picture
3700 $postuser = new stdClass();
3701 $postuserfields = explode(',', user_picture::fields());
3702 $postuser = username_load_fields_from_object($postuser, $post, null, $postuserfields);
3703 $postuser->id = $post->userid;
3704 echo '<td class="picture">';
3705 echo $OUTPUT->user_picture($postuser, array('courseid'=>$forum->course));
3706 echo "</td>\n";
3707
3708 // User name
3709 $fullname = fullname($postuser, has_capability('moodle/site:viewfullnames', $modcontext));
3710 echo '<td class="author">';
3711 echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->userid.'&amp;course='.$forum->course.'">'.$fullname.'</a>';
3712 echo "</td>\n";
3713
3714 // Group picture
3715 if ($group !== -1) { // Groups are active - group is a group data object or NULL
3716 echo '<td class="picture group">';
3717 if (!empty($group->picture) and empty($group->hidepicture)) {
3718 if ($canviewparticipants && $COURSE->groupmode) {
3719 $picturelink = true;
3720 } else {
3721 $picturelink = false;
3722 }
3723 print_group_picture($group, $forum->course, false, false, $picturelink);
3724 } else if (isset($group->id)) {
3725 if ($canviewparticipants && $COURSE->groupmode) {
3726 echo '<a href="'.$CFG->wwwroot.'/user/index.php?id='.$forum->course.'&amp;group='.$group->id.'">'.$group->name.'</a>';
3727 } else {
3728 echo $group->name;
3729 }
3730 }
3731 echo "</td>\n";
3732 }
3733
3734 if (has_capability('mod/forum:viewdiscussion', $modcontext)) { // Show the column with replies
3735 echo '<td class="replies">';
3736 echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'">';
3737 echo $post->replies.'</a>';
3738 echo "</td>\n";
3739
3740 if ($cantrack) {
3741 echo '<td class="replies">';
3742 if ($forumtracked) {
3743 if ($post->unread > 0) {
3744 echo '<span class="unread">';
3745 echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.'#unread">';
3746 echo $post->unread;
3747 echo '</a>';
3748 echo '<a title="'.$strmarkalldread.'" href="'.$CFG->wwwroot.'/mod/forum/markposts.php?f='.
3749 $forum->id.'&amp;d='.$post->discussion.'&amp;mark=read&amp;returnpage=view.php">' .
3750 '<img src="'.$OUTPUT->pix_url('t/markasread') . '" class="iconsmall" alt="'.$strmarkalldread.'" /></a>';
3751 echo '</span>';
3752 } else {
3753 echo '<span class="read">';
3754 echo $post->unread;
3755 echo '</span>';
3756 }
3757 } else {
3758 echo '<span class="read">';
3759 echo '-';
3760 echo '</span>';
3761 }
3762 echo "</td>\n";
3763 }
3764 }
3765
3766 echo '<td class="lastpost">';
3767 $usedate = (empty($post->timemodified)) ? $post->modified : $post->timemodified; // Just in case
3768 $parenturl = '';
3769 $usermodified = new stdClass();
3770 $usermodified->id = $post->usermodified;
3771 $usermodified = username_load_fields_from_object($usermodified, $post, 'um');
3772
3773 // Show link to last poster and their post if user can see them.
3774 if ($canviewparticipants) {
3775 echo '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$post->usermodified.'&amp;course='.$forum->course.'">'.
3776 fullname($usermodified).'</a><br />';
3777 $parenturl = (empty($post->lastpostid)) ? '' : '&amp;parent='.$post->lastpostid;
3778 }
3779
3780 echo '<a href="'.$CFG->wwwroot.'/mod/forum/discuss.php?d='.$post->discussion.$parenturl.'">'.
3781 userdate($usedate, $datestring).'</a>';
3782 echo "</td>\n";
3783
3784 // is_guest should be used here as this also checks whether the user is a guest in the current course.
3785 // Guests and visitors cannot subscribe - only enrolled users.
3786 if ((!is_guest($modcontext, $USER) && isloggedin()) && has_capability('mod/forum:viewdiscussion', $modcontext)) {
3787 // Discussion subscription.
3788 if (\mod_forum\subscriptions::is_subscribable($forum)) {
3789 echo '<td class="discussionsubscription">';
3790 echo forum_get_discussion_subscription_icon($forum, $post->discussion);
3791 echo '</td>';
3792 }
3793 }
3794
3795 echo "</tr>\n\n";
3796
3797 }
3798
3799 /**
3800 * Return the markup for the discussion subscription toggling icon.
3801 *
3802 * @param stdClass $forum The forum object.
3803 * @param int $discussionid The discussion to create an icon for.
3804 * @return string The generated markup.
3805 */
3806 function forum_get_discussion_subscription_icon($forum, $discussionid, $returnurl = null, $includetext = false) {
3807 global $USER, $OUTPUT, $PAGE;
3808
3809 if ($returnurl === null && $PAGE->url) {
3810 $returnurl = $PAGE->url->out();
3811 }
3812
3813 $o = '';
3814 $subscriptionstatus = \mod_forum\subscriptions::is_subscribed($USER->id, $forum, $discussionid);
3815 $subscriptionlink = new moodle_url('/mod/forum/subscribe.php', array(
3816 'sesskey' => sesskey(),
3817 'id' => $forum->id,
3818 'd' => $discussionid,
3819 'returnurl' => $returnurl,
3820 ));
3821
3822 if ($includetext) {
3823 $o .= $subscriptionstatus ? get_string('subscribed', 'mod_forum') : get_string('notsubscribed', 'mod_forum');
3824 }
3825
3826 if ($subscriptionstatus) {
3827 $output = $OUTPUT->pix_icon('t/subscribed', get_string('clicktounsubscribe', 'forum'), 'mod_forum');
3828 if ($includetext) {
3829 $output .= get_string('subscribed', 'mod_forum');
3830 }
3831
3832 return html_writer::link($subscriptionlink, $output, array(
3833 'title' => get_string('clicktounsubscribe', 'forum'),
3834 'class' => 'discussiontoggle iconsmall',
3835 'data-forumid' => $forum->id,
3836 'data-discussionid' => $discussionid,
3837 'data-includetext' => $includetext,
3838 ));
3839
3840 } else {
3841 $output = $OUTPUT->pix_icon('t/unsubscribed', get_string('clicktosubscribe', 'forum'), 'mod_forum');
3842 if ($includetext) {
3843 $output .= get_string('notsubscribed', 'mod_forum');
3844 }
3845
3846 return html_writer::link($subscriptionlink, $output, array(
3847 'title' => get_string('clicktosubscribe', 'forum'),
3848 'class' => 'discussiontoggle iconsmall',
3849 'data-forumid' => $forum->id,
3850 'data-discussionid' => $discussionid,
3851 'data-includetext' => $includetext,
3852 ));
3853 }
3854 }
3855
3856 /**
3857 * Return a pair of spans containing classes to allow the subscribe and
3858 * unsubscribe icons to be pre-loaded by a browser.
3859 *
3860 * @return string The generated markup
3861 */
3862 function forum_get_discussion_subscription_icon_preloaders() {
3863 $o = '';
3864 $o .= html_writer::span('&nbsp;', 'preload-subscribe');
3865 $o .= html_writer::span('&nbsp;', 'preload-unsubscribe');
3866 return $o;
3867 }
3868
3869 /**
3870 * Print the drop down that allows the user to select how they want to have
3871 * the discussion displayed.
3872 *
3873 * @param int $id forum id if $forumtype is 'single',
3874 * discussion id for any other forum type
3875 * @param mixed $mode forum layout mode
3876 * @param string $forumtype optional
3877 */
3878 function forum_print_mode_form($id, $mode, $forumtype='') {
3879 global $OUTPUT;
3880 if ($forumtype == 'single') {
3881 $select = new single_select(new moodle_url("/mod/forum/view.php", array('f'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
3882 $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
3883 $select->class = "forummode";
3884 } else {
3885 $select = new single_select(new moodle_url("/mod/forum/discuss.php", array('d'=>$id)), 'mode', forum_get_layout_modes(), $mode, null, "mode");
3886 $select->set_label(get_string('displaymode', 'forum'), array('class' => 'accesshide'));
3887 }
3888 echo $OUTPUT->render($select);
3889 }
3890
3891 /**
3892 * @global object
3893 * @param object $course
3894 * @param string $search
3895 * @return string
3896 */
3897 function forum_search_form($course, $search='') {
3898 global $CFG, $OUTPUT;
3899
3900 $output = '<div class="forumsearch">';
3901 $output .= '<form action="'.$CFG->wwwroot.'/mod/forum/search.php" style="display:inline">';
3902 $output .= '<fieldset class="invisiblefieldset">';
3903 $output .= $OUTPUT->help_icon('search');
3904 $output .= '<label class="accesshide" for="search" >'.get_string('search', 'forum').'</label>';
3905 $output .= '<input id="search" name="search" type="text" size="18" value="'.s($search, true).'" />';
3906 $output .= '<label class="accesshide" for="searchforums" >'.get_string('searchforums', 'forum').'</label>';
3907 $output .= '<input id="searchforums" value="'.get_string('searchforums', 'forum').'" type="submit" />';
3908 $output .= '<input name="id" type="hidden" value="'.$course->id.'" />';
3909 $output .= '</fieldset>';
3910 $output .= '</form>';
3911 $output .= '</div>';
3912
3913 return $output;
3914 }
3915
3916
3917 /**
3918 * @global object
3919 * @global object
3920 */
3921 function forum_set_return() {
3922 global $CFG, $SESSION;
3923
3924 if (! isset($SESSION->fromdiscussion)) {
3925 if (!empty($_SERVER['HTTP_REFERER'])) {
3926 $referer = $_SERVER['HTTP_REFERER'];
3927 } else {
3928 $referer = "";
3929 }
3930 // If the referer is NOT a login screen then save it.
3931 if (! strncasecmp("$CFG->wwwroot/login", $referer, 300)) {
3932 $SESSION->fromdiscussion = $_SERVER["HTTP_REFERER"];
3933 }
3934 }
3935 }
3936
3937
3938 /**
3939 * @global object
3940 * @param string $default
3941 * @return string
3942 */
3943 function forum_go_back_to($default) {
3944 global $SESSION;
3945
3946 if (!empty($SESSION->fromdiscussion)) {
3947 $returnto = $SESSION->fromdiscussion;
3948 unset($SESSION->fromdiscussion);
3949 return $returnto;
3950 } else {
3951 return $default;
3952 }
3953 }
3954
3955 /**
3956 * Given a discussion object that is being moved to $forumto,
3957 * this function checks all posts in that discussion
3958 * for attachments, and if any are found, these are
3959 * moved to the new forum directory.
3960 *
3961 * @global object
3962 * @param object $discussion
3963 * @param int $forumfrom source forum id
3964 * @param int $forumto target forum id
3965 * @return bool success
3966 */
3967 function forum_move_attachments($discussion, $forumfrom, $forumto) {
3968 global $DB;
3969
3970 $fs = get_file_storage();
3971
3972 $newcm = get_coursemodule_from_instance('forum', $forumto);
3973 $oldcm = get_coursemodule_from_instance('forum', $forumfrom);
3974
3975 $newcontext = context_module::instance($newcm->id);
3976 $oldcontext = context_module::instance($oldcm->id);
3977
3978 // loop through all posts, better not use attachment flag ;-)
3979 if ($posts = $DB->get_records('forum_posts', array('discussion'=>$discussion->id), '', 'id, attachment')) {
3980 foreach ($posts as $post) {
3981 $fs->move_area_files_to_new_context($oldcontext->id,
3982 $newcontext->id, 'mod_forum', 'post', $post->id);
3983 $attachmentsmoved = $fs->move_area_files_to_new_context($oldcontext->id,
3984 $newcontext->id, 'mod_forum', 'attachment', $post->id);
3985 if ($attachmentsmoved > 0 && $post->attachment != '1') {
3986 // Weird - let's fix it
3987 $post->attachment = '1';
3988 $DB->update_record('forum_posts', $post);
3989 } else if ($attachmentsmoved == 0 && $post->attachment != '') {
3990 // Weird - let's fix it
3991 $post->attachment = '';
3992 $DB->update_record('forum_posts', $post);
3993 }
3994 }
3995 }
3996
3997 return true;
3998 }
3999
4000 /**
4001 * Returns attachments as formated text/html optionally with separate images
4002 *
4003 * @global object
4004 * @global object
4005 * @global object
4006 * @param object $post
4007 * @param object $cm
4008 * @param string $type html/text/separateimages
4009 * @return mixed string or array of (html text withouth images and image HTML)
4010 */
4011 function forum_print_attachments($post, $cm, $type) {
4012 global $CFG, $DB, $USER, $OUTPUT;
4013
4014 if (empty($post->attachment)) {
4015 return $type !== 'separateimages' ? '' : array('', '');
4016 }
4017
4018 if (!in_array($type, array('separateimages', 'html', 'text'))) {
4019 return $type !== 'separateimages' ? '' : array('', '');
4020 }
4021
4022 if (!$context = context_module::instance($cm->id)) {
4023 return $type !== 'separateimages' ? '' : array('', '');
4024 }
4025 $strattachment = get_string('attachment', 'forum');
4026
4027 $fs = get_file_storage();
4028
4029 $imagereturn = '';
4030 $output = '';
4031
4032 $canexport = !empty($CFG->enableportfolios) && (has_capability('mod/forum:exportpost', $context) || ($post->userid == $USER->id && has_capability('mod/forum:exportownpost', $context)));
4033
4034 if ($canexport) {
4035 require_once($CFG->libdir.'/portfoliolib.php');
4036 }
4037
4038 // We retrieve all files according to the time that they were created. In the case that several files were uploaded
4039 // at the sametime (e.g. in the case of drag/drop upload) we revert to using the filename.
4040 $files = $fs->get_area_files($context->id, 'mod_forum', 'attachment', $post->id, "filename", false);
4041 if ($files) {
4042 if ($canexport) {
4043 $button = new portfolio_add_button();
4044 }
4045 foreach ($files as $file) {
4046 $filename = $file->get_filename();
4047 $mimetype = $file->get_mimetype();
4048 $iconimage = $OUTPUT->pix_icon(file_file_icon($file), get_mimetype_description($file), 'moodle', array('class' => 'icon'));
4049 $path = file_encode_url($CFG->wwwroot.'/pluginfile.php', '/'.$context->id.'/mod_forum/attachment/'.$post->id.'/'.$filename);
4050
4051 if ($type == 'html') {
4052 $output .= "<a href=\"$path\">$iconimage</a> ";
4053 $output .= "<a href=\"$path\">".s($filename)."</a>";
4054 if ($canexport) {
4055 $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
4056 $button->set_format_by_file($file);
4057 $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
4058 }
4059 $output .= "<br />";
4060
4061 } else if ($type == 'text') {
4062 $output .= "$strattachment ".s($filename).":\n$path\n";
4063
4064 } else { //'returnimages'
4065 if (in_array($mimetype, array('image/gif', 'image/jpeg', 'image/png'))) {
4066 // Image attachments don't get printed as links
4067 $imagereturn .= "<br /><img src=\"$path\" alt=\"\" />";
4068 if ($canexport) {
4069 $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
4070 $button->set_format_by_file($file);
4071 $imagereturn .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
4072 }
4073 } else {
4074 $output .= "<a href=\"$path\">$iconimage</a> ";
4075 $output .= format_text("<a href=\"$path\">".s($filename)."</a>", FORMAT_HTML, array('context'=>$context));
4076 if ($canexport) {
4077 $button->set_callback_options('forum_portfolio_caller', array('postid' => $post->id, 'attachment' => $file->get_id()), 'mod_forum');
4078 $button->set_format_by_file($file);
4079 $output .= $button->to_html(PORTFOLIO_ADD_ICON_LINK);
4080 }
4081 $output .= '<br />';
4082 }
4083 }
4084
4085 if (!empty($CFG->enableplagiarism)) {
4086 require_once($CFG->libdir.'/plagiarismlib.php');
4087 $output .= plagiarism_get_links(array('userid' => $post->userid,
4088 'file' => $file,
4089 'cmid' => $cm->id,
4090 'course' => $post->course,
4091 'forum' => $post->forum));
4092 $output .= '<br />';
4093 }
4094 }
4095 }
4096
4097 if ($type !== 'separateimages') {
4098 return $output;
4099
4100 } else {
4101 return array($output, $imagereturn);
4102 }
4103 }
4104
4105 ////////////////////////////////////////////////////////////////////////////////
4106 // File API //
4107 ////////////////////////////////////////////////////////////////////////////////
4108
4109 /**
4110 * Lists all browsable file areas
4111 *
4112 * @package mod_forum
4113 * @category files
4114 * @param stdClass $course course object
4115 * @param stdClass $cm course module object
4116 * @param stdClass $context context object
4117 * @return array
4118 */
4119 function forum_get_file_areas($course, $cm, $context) {
4120 return array(
4121 'attachment' => get_string('areaattachment', 'mod_forum'),
4122 'post' => get_string('areapost', 'mod_forum'),
4123 );
4124 }
4125
4126 /**
4127 * File browsing support for forum module.
4128 *
4129 * @package mod_forum
4130 * @category files
4131 * @param stdClass $browser file browser object
4132 * @param stdClass $areas file areas
4133 * @param stdClass $course course object
4134 * @param stdClass $cm course module
4135 * @param stdClass $context context module
4136 * @param string $filearea file area
4137 * @param int $itemid item ID
4138 * @param string $filepath file path
4139 * @param string $filename file name
4140 * @return file_info instance or null if not found
4141 */
4142 function forum_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
4143 global $CFG, $DB, $USER;
4144
4145 if ($context->contextlevel != CONTEXT_MODULE) {
4146 return null;
4147 }
4148
4149 // filearea must contain a real area
4150 if (!isset($areas[$filearea])) {
4151 return null;
4152 }
4153
4154 // Note that forum_user_can_see_post() additionally allows access for parent roles
4155 // and it explicitly checks qanda forum type, too. One day, when we stop requiring
4156 // course:managefiles, we will need to extend this.
4157 if (!has_capability('mod/forum:viewdiscussion', $context)) {
4158 return null;
4159 }
4160
4161 if (is_null($itemid)) {
4162 require_once($CFG->dirroot.'/mod/forum/locallib.php');
4163 return new forum_file_info_container($browser, $course, $cm, $context, $areas, $filearea);
4164 }
4165
4166 static $cached = array();
4167 // $cached will store last retrieved post, discussion and forum. To make sure that the cache
4168 // is cleared between unit tests we check if this is the same session
4169 if (!isset($cached['sesskey']) || $cached['sesskey'] != sesskey()) {
4170 $cached = array('sesskey' => sesskey());
4171 }
4172
4173 if (isset($cached['post']) && $cached['post']->id == $itemid) {
4174 $post = $cached['post'];
4175 } else if ($post = $DB->get_record('forum_posts', array('id' => $itemid))) {
4176 $cached['post'] = $post;
4177 } else {
4178 return null;
4179 }
4180
4181 if (isset($cached['discussion']) && $cached['discussion']->id == $post->discussion) {
4182 $discussion = $cached['discussion'];
4183 } else if ($discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion))) {
4184 $cached['discussion'] = $discussion;
4185 } else {
4186 return null;
4187 }
4188
4189 if (isset($cached['forum']) && $cached['forum']->id == $cm->instance) {
4190 $forum = $cached['forum'];
4191 } else if ($forum = $DB->get_record('forum', array('id' => $cm->instance))) {
4192 $cached['forum'] = $forum;
4193 } else {
4194 return null;
4195 }
4196
4197 $fs = get_file_storage();
4198 $filepath = is_null($filepath) ? '/' : $filepath;
4199 $filename = is_null($filename) ? '.' : $filename;
4200 if (!($storedfile = $fs->get_file($context->id, 'mod_forum', $filearea, $itemid, $filepath, $filename))) {
4201 return null;
4202 }
4203
4204 // Checks to see if the user can manage files or is the owner.
4205 // TODO MDL-33805 - Do not use userid here and move the capability check above.
4206 if (!has_capability('moodle/course:managefiles', $context) && $storedfile->get_userid() != $USER->id) {
4207 return null;
4208 }
4209 // Make sure groups allow this user to see this file
4210 if ($discussion->groupid > 0 && !has_capability('moodle/site:accessallgroups', $context)) {
4211 $groupmode = groups_get_activity_groupmode($cm, $course);
4212 if ($groupmode == SEPARATEGROUPS && !groups_is_member($discussion->groupid)) {
4213 return null;
4214 }
4215 }
4216
4217 // Make sure we're allowed to see it...
4218 if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
4219 return null;
4220 }
4221
4222 $urlbase = $CFG->wwwroot.'/pluginfile.php';
4223 return new file_info_stored($browser, $context, $storedfile, $urlbase, $itemid, true, true, false, false);
4224 }
4225
4226 /**
4227 * Serves the forum attachments. Implements needed access control ;-)
4228 *
4229 * @package mod_forum
4230 * @category files
4231 * @param stdClass $course course object
4232 * @param stdClass $cm course module object
4233 * @param stdClass $context context object
4234 * @param string $filearea file area
4235 * @param array $args extra arguments
4236 * @param bool $forcedownload whether or not force download
4237 * @param array $options additional options affecting the file serving
4238 * @return bool false if file not found, does not return if found - justsend the file
4239 */
4240 function forum_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
4241 global $CFG, $DB;
4242
4243 if ($context->contextlevel != CONTEXT_MODULE) {
4244 return false;
4245 }
4246
4247 require_course_login($course, true, $cm);
4248
4249 $areas = forum_get_file_areas($course, $cm, $context);
4250
4251 // filearea must contain a real area
4252 if (!isset($areas[$filearea])) {
4253 return false;
4254 }
4255
4256 $postid = (int)array_shift($args);
4257
4258 if (!$post = $DB->get_record('forum_posts', array('id'=>$postid))) {
4259 return false;
4260 }
4261
4262 if (!$discussion = $DB->get_record('forum_discussions', array('id'=>$post->discussion))) {
4263 return false;
4264 }
4265
4266 if (!$forum = $DB->get_record('forum', array('id'=>$cm->instance))) {
4267 return false;
4268 }
4269
4270 $fs = get_file_storage();
4271 $relativepath = implode('/', $args);
4272 $fullpath = "/$context->id/mod_forum/$filearea/$postid/$relativepath";
4273 if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
4274 return false;
4275 }
4276
4277 // Make sure groups allow this user to see this file
4278 if ($discussion->groupid > 0) {
4279 $groupmode = groups_get_activity_groupmode($cm, $course);
4280 if ($groupmode == SEPARATEGROUPS) {
4281 if (!groups_is_member($discussion->groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
4282 return false;
4283 }
4284 }
4285 }
4286
4287 // Make sure we're allowed to see it...
4288 if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
4289 return false;
4290 }
4291
4292 // finally send the file
4293 send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
4294 }
4295
4296 /**
4297 * If successful, this function returns the name of the file
4298 *
4299 * @global object
4300 * @param object $post is a full post record, including course and forum
4301 * @param object $forum
4302 * @param object $cm
4303 * @param mixed $mform
4304 * @param string $unused
4305 * @return bool
4306 */
4307 function forum_add_attachment($post, $forum, $cm, $mform=null, $unused=null) {
4308 global $DB;
4309
4310 if (empty($mform)) {
4311 return false;
4312 }
4313
4314 if (empty($post->attachments)) {
4315 return true; // Nothing to do
4316 }
4317
4318 $context = context_module::instance($cm->id);
4319
4320 $info = file_get_draft_area_info($post->attachments);
4321 $present = ($info['filecount']>0) ? '1' : '';
4322 file_save_draft_area_files($post->attachments, $context->id, 'mod_forum', 'attachment', $post->id,
4323 mod_forum_post_form::attachment_options($forum));
4324
4325 $DB->set_field('forum_posts', 'attachment', $present, array('id'=>$post->id));
4326
4327 return true;
4328 }
4329
4330 /**
4331 * Add a new post in an existing discussion.
4332 *
4333 * @global object
4334 * @global object
4335 * @global object
4336 * @param object $post
4337 * @param mixed $mform
4338 * @param string $unused formerly $message, renamed in 2.8 as it was unused.
4339 * @return int
4340 */
4341 function forum_add_new_post($post, $mform, $unused = null) {
4342 global $USER, $CFG, $DB;
4343
4344 $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion));
4345 $forum = $DB->get_record('forum', array('id' => $discussion->forum));
4346 $cm = get_coursemodule_from_instance('forum', $forum->id);
4347 $context = context_module::instance($cm->id);
4348
4349 $post->created = $post->modified = time();
4350 $post->mailed = FORUM_MAILED_PENDING;
4351 $post->userid = $USER->id;
4352 $post->attachment = "";
4353 if (!isset($post->totalscore)) {
4354 $post->totalscore = 0;
4355 }
4356 if (!isset($post->mailnow)) {
4357 $post->mailnow = 0;
4358 }
4359
4360 $post->id = $DB->insert_record("forum_posts", $post);
4361 $post->message = file_save_draft_area_files($post->itemid, $context->id, 'mod_forum', 'post', $post->id,
4362 mod_forum_post_form::editor_options($context, null), $post->message);
4363 $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
4364 forum_add_attachment($post, $forum, $cm, $mform);
4365
4366 // Update discussion modified date
4367 $DB->set_field("forum_discussions", "timemodified", $post->modified, array("id" => $post->discussion));
4368 $DB->set_field("forum_discussions", "usermodified", $post->userid, array("id" => $post->discussion));
4369
4370 if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
4371 forum_tp_mark_post_read($post->userid, $post, $post->forum);
4372 }
4373
4374 // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
4375 forum_trigger_content_uploaded_event($post, $cm, 'forum_add_new_post');
4376
4377 return $post->id;
4378 }
4379
4380 /**
4381 * Update a post
4382 *
4383 * @global object
4384 * @global object
4385 * @global object
4386 * @param object $post
4387 * @param mixed $mform
4388 * @param string $message
4389 * @return bool
4390 */
4391 function forum_update_post($post, $mform, &$message) {
4392 global $USER, $CFG, $DB;
4393
4394 $discussion = $DB->get_record('forum_discussions', array('id' => $post->discussion));
4395 $forum = $DB->get_record('forum', array('id' => $discussion->forum));
4396 $cm = get_coursemodule_from_instance('forum', $forum->id);
4397 $context = context_module::instance($cm->id);
4398
4399 $post->modified = time();
4400
4401 $DB->update_record('forum_posts', $post);
4402
4403 $discussion->timemodified = $post->modified; // last modified tracking
4404 $discussion->usermodified = $post->userid; // last modified tracking
4405
4406 if (!$post->parent) { // Post is a discussion starter - update discussion title and times too
4407 $discussion->name = $post->subject;
4408 $discussion->timestart = $post->timestart;
4409 $discussion->timeend = $post->timeend;
4410 }
4411 $post->message = file_save_draft_area_files($post->itemid, $context->id, 'mod_forum', 'post', $post->id,
4412 mod_forum_post_form::editor_options($context, $post->id), $post->message);
4413 $DB->set_field('forum_posts', 'message', $post->message, array('id'=>$post->id));
4414
4415 $DB->update_record('forum_discussions', $discussion);
4416
4417 forum_add_attachment($post, $forum, $cm, $mform, $message);
4418
4419 if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
4420 forum_tp_mark_post_read($post->userid, $post, $post->forum);
4421 }
4422
4423 // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
4424 forum_trigger_content_uploaded_event($post, $cm, 'forum_update_post');
4425
4426 return true;
4427 }
4428
4429 /**
4430 * Given an object containing all the necessary data,
4431 * create a new discussion and return the id
4432 *
4433 * @param object $post
4434 * @param mixed $mform
4435 * @param string $unused
4436 * @param int $userid
4437 * @return object
4438 */
4439 function forum_add_discussion($discussion, $mform=null, $unused=null, $userid=null) {
4440 global $USER, $CFG, $DB;
4441
4442 $timenow = time();
4443
4444 if (is_null($userid)) {
4445 $userid = $USER->id;
4446 }
4447
4448 // The first post is stored as a real post, and linked
4449 // to from the discuss entry.
4450
4451 $forum = $DB->get_record('forum', array('id'=>$discussion->forum));
4452 $cm = get_coursemodule_from_instance('forum', $forum->id);
4453
4454 $post = new stdClass();
4455 $post->discussion = 0;
4456 $post->parent = 0;
4457 $post->userid = $userid;
4458 $post->created = $timenow;
4459 $post->modified = $timenow;
4460 $post->mailed = FORUM_MAILED_PENDING;
4461 $post->subject = $discussion->name;
4462 $post->message = $discussion->message;
4463 $post->messageformat = $discussion->messageformat;
4464 $post->messagetrust = $discussion->messagetrust;
4465 $post->attachments = isset($discussion->attachments) ? $discussion->attachments : null;
4466 $post->forum = $forum->id; // speedup
4467 $post->course = $forum->course; // speedup
4468 $post->mailnow = $discussion->mailnow;
4469
4470 $post->id = $DB->insert_record("forum_posts", $post);
4471
4472 // TODO: Fix the calling code so that there always is a $cm when this function is called
4473 if (!empty($cm->id) && !empty($discussion->itemid)) { // In "single simple discussions" this may not exist yet
4474 $context = context_module::instance($cm->id);
4475 $text = file_save_draft_area_files($discussion->itemid, $context->id, 'mod_forum', 'post', $post->id,
4476 mod_forum_post_form::editor_options($context, null), $post->message);
4477 $DB->set_field('forum_posts', 'message', $text, array('id'=>$post->id));
4478 }
4479
4480 // Now do the main entry for the discussion, linking to this first post
4481
4482 $discussion->firstpost = $post->id;
4483 $discussion->timemodified = $timenow;
4484 $discussion->usermodified = $post->userid;
4485 $discussion->userid = $userid;
4486 $discussion->assessed = 0;
4487
4488 $post->discussion = $DB->insert_record("forum_discussions", $discussion);
4489
4490 // Finally, set the pointer on the post.
4491 $DB->set_field("forum_posts", "discussion", $post->discussion, array("id"=>$post->id));
4492
4493 if (!empty($cm->id)) {
4494 forum_add_attachment($post, $forum, $cm, $mform, $unused);
4495 }
4496
4497 if (forum_tp_can_track_forums($forum) && forum_tp_is_tracked($forum)) {
4498 forum_tp_mark_post_read($post->userid, $post, $post->forum);
4499 }
4500
4501 // Let Moodle know that assessable content is uploaded (eg for plagiarism detection)
4502 if (!empty($cm->id)) {
4503 forum_trigger_content_uploaded_event($post, $cm, 'forum_add_discussion');
4504 }
4505
4506 return $post->discussion;
4507 }
4508
4509
4510 /**
4511 * Deletes a discussion and handles all associated cleanup.
4512 *
4513 * @global object
4514 * @param object $discussion Discussion to delete
4515 * @param bool $fulldelete True when deleting entire forum
4516 * @param object $course Course
4517 * @param object $cm Course-module
4518 * @param object $forum Forum
4519 * @return bool
4520 */
4521 function forum_delete_discussion($discussion, $fulldelete, $course, $cm, $forum) {
4522 global $DB, $CFG;
4523 require_once($CFG->libdir.'/completionlib.php');
4524
4525 $result = true;
4526
4527 if ($posts = $DB->get_records("forum_posts", array("discussion" => $discussion->id))) {
4528 foreach ($posts as $post) {
4529 $post->course = $discussion->course;
4530 $post->forum = $discussion->forum;
4531 if (!forum_delete_post($post, 'ignore', $course, $cm, $forum, $fulldelete)) {
4532 $result = false;
4533 }
4534 }
4535 }
4536
4537 forum_tp_delete_read_records(-1, -1, $discussion->id);
4538
4539 // Discussion subscriptions must be removed before discussions because of key constraints.
4540 $DB->delete_records('forum_discussion_subs', array('discussion' => $discussion->id));
4541 if (!$DB->delete_records("forum_discussions", array("id" => $discussion->id))) {
4542 $result = false;
4543 }
4544
4545 // Update completion state if we are tracking completion based on number of posts
4546 // But don't bother when deleting whole thing
4547 if (!$fulldelete) {
4548 $completion = new completion_info($course);
4549 if ($completion->is_enabled($cm) == COMPLETION_TRACKING_AUTOMATIC &&
4550 ($forum->completiondiscussions || $forum->completionreplies || $forum->completionposts)) {
4551 $completion->update_state($cm, COMPLETION_INCOMPLETE, $discussion->userid);
4552 }
4553 }
4554
4555 return $result;
4556 }
4557
4558
4559 /**
4560 * Deletes a single forum post.
4561 *
4562 * @global object
4563 * @param object $post Forum post object
4564 * @param mixed $children Whether to delete children. If false, returns false
4565 * if there are any children (without deleting the post). If true,
4566 * recursively deletes all children. If set to special value 'ignore', deletes
4567 * post regardless of children (this is for use only when deleting all posts
4568 * in a disussion).
4569 * @param object $course Course
4570 * @param object $cm Course-module
4571 * @param object $forum Forum
4572 * @param bool $skipcompletion True to skip updating completion state if it
4573 * would otherwise be updated, i.e. when deleting entire forum anyway.
4574 * @return bool
4575 */
4576 function forum_delete_post($post, $children, $course, $cm, $forum, $skipcompletion=false) {
4577 global $DB, $CFG;
4578 require_once($CFG->libdir.'/completionlib.php');
4579
4580 $context = context_module::instance($cm->id);
4581
4582 if ($children !== 'ignore' && ($childposts = $DB->get_records('forum_posts', array('parent'=>$post->id)))) {
4583 if ($children) {
4584 foreach ($childposts as $childpost) {
4585 forum_delete_post($childpost, true, $course, $cm, $forum, $skipcompletion);
4586 }
4587 } else {
4588 return false;
4589 }
4590 }
4591
4592 // Delete ratings.
4593 require_once($CFG->dirroot.'/rating/lib.php');
4594 $delopt = new stdClass;
4595 $delopt->contextid = $context->id;
4596 $delopt->component = 'mod_forum';
4597 $delopt->ratingarea = 'post';
4598 $delopt->itemid = $post->id;
4599 $rm = new rating_manager();
4600 $rm->delete_ratings($delopt);
4601
4602 // Delete attachments.
4603 $fs = get_file_storage();
4604 $fs->delete_area_files($context->id, 'mod_forum', 'attachment', $post->id);
4605 $fs->delete_area_files($context->id, 'mod_forum', 'post', $post->id);
4606
4607 // Delete cached RSS feeds.
4608 if (!empty($CFG->enablerssfeeds)) {
4609 require_once($CFG->dirroot.'/mod/forum/rsslib.php');
4610 forum_rss_delete_file($forum);
4611 }
4612
4613 if ($DB->delete_records("forum_posts", array("id" => $post->id))) {
4614
4615 forum_tp_delete_read_records(-1, $post->id);
4616
4617 // Just in case we are deleting the last post
4618 forum_discussion_update_last_post($post->discussion);
4619
4620 // Update completion state if we are tracking completion based on number of posts
4621 // But don't bother when deleting whole thing
4622
4623 if (!$skipcompletion) {
4624 $completion = new completion_info($course);
4625 if ($completion->is_enabled($cm) == COMPLETION_TRACKING_AUTOMATIC &&
4626 ($forum->completiondiscussions || $forum->completionreplies || $forum->completionposts)) {
4627 $completion->update_state($cm, COMPLETION_INCOMPLETE, $post->userid);
4628 }
4629 }
4630
4631 return true;
4632 }
4633 return false;
4634 }
4635
4636 /**
4637 * Sends post content to plagiarism plugin
4638 * @param object $post Forum post object
4639 * @param object $cm Course-module
4640 * @param string $name
4641 * @return bool
4642 */
4643 function forum_trigger_content_uploaded_event($post, $cm, $name) {
4644 $context = context_module::instance($cm->id);
4645 $fs = get_file_storage();
4646 $files = $fs->get_area_files($context->id, 'mod_forum', 'attachment', $post->id, "timemodified", false);
4647 $params = array(
4648 'context' => $context,
4649 'objectid' => $post->id,
4650 'other' => array(
4651 'content' => $post->message,
4652 'pathnamehashes' => array_keys($files),
4653 'discussionid' => $post->discussion,
4654 'triggeredfrom' => $name,
4655 )
4656 );
4657 $event = \mod_forum\event\assessable_uploaded::create($params);
4658 $event->trigger();
4659 return true;
4660 }
4661
4662 /**
4663 * @global object
4664 * @param object $post
4665 * @param bool $children
4666 * @return int
4667 */
4668 function forum_count_replies($post, $children=true) {
4669 global $DB;
4670 $count = 0;
4671
4672 if ($children) {
4673 if ($childposts = $DB->get_records('forum_posts', array('parent' => $post->id))) {
4674 foreach ($childposts as $childpost) {
4675 $count ++; // For this child
4676 $count += forum_count_replies($childpost, true);
4677 }
4678 }
4679 } else {
4680 $count += $DB->count_records('forum_posts', array('parent' => $post->id));
4681 }
4682
4683 return $count;
4684 }
4685
4686 /**
4687 * Given a new post, subscribes or unsubscribes as appropriate.
4688 * Returns some text which describes what happened.
4689 *
4690 * @param object $fromform The submitted form
4691 * @param stdClass $forum The forum record
4692 * @param stdClass $discussion The forum discussion record
4693 * @return string
4694 */
4695 function forum_post_subscription($fromform, $forum, $discussion) {
4696 global $USER;
4697
4698 if (\mod_forum\subscriptions::is_forcesubscribed($forum)) {
4699 return "";
4700 } else if (\mod_forum\subscriptions::subscription_disabled($forum)) {
4701 $subscribed = \mod_forum\subscriptions::is_subscribed($USER->id, $forum);
4702 if ($subscribed && !has_capability('moodle/course:manageactivities', context_course::instance($forum->course), $USER->id)) {
4703 // This user should not be subscribed to the forum.
4704 \mod_forum\subscriptions::unsubscribe_user($USER->id, $forum);
4705 }
4706 return "";
4707 }
4708
4709 $info = new stdClass();
4710 $info->name = fullname($USER);
4711 $info->discussion = format_string($discussion->name);
4712 $info->forum = format_string($forum->name);
4713
4714 if ($fromform->discussionsubscribe) {
4715 if ($result = \mod_forum\subscriptions::subscribe_user_to_discussion($USER->id, $discussion)) {
4716 return html_writer::tag('p', get_string('discussionnowsubscribed', 'forum', $info));
4717 }
4718 } else {
4719 if ($result = \mod_forum\subscriptions::unsubscribe_user_from_discussion($USER->id, $discussion)) {
4720 return html_writer::tag('p', get_string('discussionnownotsubscribed', 'forum', $info));
4721 }
4722 }
4723
4724 return '';
4725 }
4726
4727 /**
4728 * Generate and return the subscribe or unsubscribe link for a forum.
4729 *
4730 * @param object $forum the forum. Fields used are $forum->id and $forum->forcesubscribe.
4731 * @param object $context the context object for this forum.
4732 * @param array $messages text used for the link in its various states
4733 * (subscribed, unsubscribed, forcesubscribed or cantsubscribe).
4734 * Any strings not passed in are taken from the $defaultmessages array
4735 * at the top of the function.
4736 * @param bool $cantaccessagroup
4737 * @param bool $fakelink
4738 * @param bool $backtoindex
4739 * @param array $subscribed_forums
4740 * @return string
4741 */
4742 function forum_get_subscribe_link($forum, $context, $messages = array(), $cantaccessagroup = false, $fakelink=true, $backtoindex=false, $subscribed_forums=null) {
4743 global $CFG, $USER, $PAGE, $OUTPUT;
4744 $defaultmessages = array(
4745 'subscribed' => get_string('unsubscribe', 'forum'),
4746 'unsubscribed' => get_string('subscribe', 'forum'),
4747 'cantaccessgroup' => get_string('no'),
4748 'forcesubscribed' => get_string('everyoneissubscribed', 'forum'),
4749 'cantsubscribe' => get_string('disallowsubscribe','forum')
4750 );
4751 $messages = $messages + $defaultmessages;
4752
4753 if (\mod_forum\subscriptions::is_forcesubscribed($forum)) {
4754 return $messages['forcesubscribed'];
4755 } else if (\mod_forum\subscriptions::subscription_disabled($forum) &&
4756 !has_capability('mod/forum:managesubscriptions', $context)) {
4757 return $messages['cantsubscribe'];
4758 } else if ($cantaccessagroup) {
4759 return $messages['cantaccessgroup'];
4760 } else {
4761 if (!is_enrolled($context, $USER, '', true)) {
4762 return '';
4763 }
4764
4765 $subscribed = \mod_forum\subscriptions::is_subscribed($USER->id, $forum);
4766 if ($subscribed) {
4767 $linktext = $messages['subscribed'];
4768 $linktitle = get_string('subscribestop', 'forum');
4769 } else {
4770 $linktext = $messages['unsubscribed'];
4771 $linktitle = get_string('subscribestart', 'forum');
4772 }
4773
4774 $options = array();
4775 if ($backtoindex) {
4776 $backtoindexlink = '&amp;backtoindex=1';
4777 $options['backtoindex'] = 1;
4778 } else {
4779 $backtoindexlink = '';
4780 }
4781 $link = '';
4782
4783 if ($fakelink) {
4784 $PAGE->requires->js('/mod/forum/forum.js');
4785 $PAGE->requires->js_function_call('forum_produce_subscribe_link', array($forum->id, $backtoindexlink, $linktext, $linktitle));
4786 $link = "<noscript>";
4787 }
4788 $options['id'] = $forum->id;
4789 $options['sesskey'] = sesskey();
4790 $url = new moodle_url('/mod/forum/subscribe.php', $options);
4791 $link .= $OUTPUT->single_button($url, $linktext, 'get', array('title'=>$linktitle));
4792 if ($fakelink) {
4793 $link .= '</noscript>';
4794 }
4795
4796 return $link;
4797 }
4798 }
4799
4800 /**
4801 * Returns true if user created new discussion already
4802 *
4803 * @global object
4804 * @global object
4805 * @param int $forumid
4806 * @param int $userid
4807 * @return bool
4808 */
4809 function forum_user_has_posted_discussion($forumid, $userid) {
4810 global $CFG, $DB;
4811
4812 $sql = "SELECT 'x'
4813 FROM {forum_discussions} d, {forum_posts} p
4814 WHERE d.forum = ? AND p.discussion = d.id AND p.parent = 0 and p.userid = ?";
4815
4816 return $DB->record_exists_sql($sql, array($forumid, $userid));
4817 }
4818
4819 /**
4820 * @global object
4821 * @global object
4822 * @param int $forumid
4823 * @param int $userid
4824 * @return array
4825 */
4826 function forum_discussions_user_has_posted_in($forumid, $userid) {
4827 global $CFG, $DB;
4828
4829 $haspostedsql = "SELECT d.id AS id,
4830 d.*
4831 FROM {forum_posts} p,
4832 {forum_discussions} d
4833 WHERE p.discussion = d.id
4834 AND d.forum = ?
4835 AND p.userid = ?";
4836
4837 return $DB->get_records_sql($haspostedsql, array($forumid, $userid));
4838 }
4839
4840 /**
4841 * @global object
4842 * @global object
4843 * @param int $forumid
4844 * @param int $did
4845 * @param int $userid
4846 * @return bool
4847 */
4848 function forum_user_has_posted($forumid, $did, $userid) {
4849 global $DB;
4850
4851 if (empty($did)) {
4852 // posted in any forum discussion?
4853 $sql = "SELECT 'x'
4854 FROM {forum_posts} p
4855 JOIN {forum_discussions} d ON d.id = p.discussion
4856 WHERE p.userid = :userid AND d.forum = :forumid";
4857 return $DB->record_exists_sql($sql, array('forumid'=>$forumid,'userid'=>$userid));
4858 } else {
4859 return $DB->record_exists('forum_posts', array('discussion'=>$did,'userid'=>$userid));
4860 }
4861 }
4862
4863 /**
4864 * Returns creation time of the first user's post in given discussion
4865 * @global object $DB
4866 * @param int $did Discussion id
4867 * @param int $userid User id
4868 * @return int|bool post creation time stamp or return false
4869 */
4870 function forum_get_user_posted_time($did, $userid) {
4871 global $DB;
4872
4873 $posttime = $DB->get_field('forum_posts', 'MIN(created)', array('userid'=>$userid, 'discussion'=>$did));
4874 if (empty($posttime)) {
4875 return false;
4876 }
4877 return $posttime;
4878 }
4879
4880 /**
4881 * @global object
4882 * @param object $forum
4883 * @param object $currentgroup
4884 * @param int $unused
4885 * @param object $cm
4886 * @param object $context
4887 * @return bool
4888 */
4889 function forum_user_can_post_discussion($forum, $currentgroup=null, $unused=-1, $cm=NULL, $context=NULL) {
4890 // $forum is an object
4891 global $USER;
4892
4893 // shortcut - guest and not-logged-in users can not post
4894 if (isguestuser() or !isloggedin()) {
4895 return false;
4896 }
4897
4898 if (!$cm) {
4899 debugging('missing cm', DEBUG_DEVELOPER);
4900 if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
4901 print_error('invalidcoursemodule');
4902 }
4903 }
4904
4905 if (!$context) {
4906 $context = context_module::instance($cm->id);
4907 }
4908
4909 if ($currentgroup === null) {
4910 $currentgroup = groups_get_activity_group($cm);
4911 }
4912
4913 $groupmode = groups_get_activity_groupmode($cm);
4914
4915 if ($forum->type == 'news') {
4916 $capname = 'mod/forum:addnews';
4917 } else if ($forum->type == 'qanda') {
4918 $capname = 'mod/forum:addquestion';
4919 } else {
4920 $capname = 'mod/forum:startdiscussion';
4921 }
4922
4923 if (!has_capability($capname, $context)) {
4924 return false;
4925 }
4926
4927 if ($forum->type == 'single') {
4928 return false;
4929 }
4930
4931 if ($forum->type == 'eachuser') {
4932 if (forum_user_has_posted_discussion($forum->id, $USER->id)) {
4933 return false;
4934 }
4935 }
4936
4937 if (!$groupmode or has_capability('moodle/site:accessallgroups', $context)) {
4938 return true;
4939 }
4940
4941 if ($currentgroup) {
4942 return groups_is_member($currentgroup);
4943 } else {
4944 // no group membership and no accessallgroups means no new discussions
4945 // reverted to 1.7 behaviour in 1.9+, buggy in 1.8.0-1.9.0
4946 return false;
4947 }
4948 }
4949
4950 /**
4951 * This function checks whether the user can reply to posts in a forum
4952 * discussion. Use forum_user_can_post_discussion() to check whether the user
4953 * can start discussions.
4954 *
4955 * @global object
4956 * @global object
4957 * @uses DEBUG_DEVELOPER
4958 * @uses CONTEXT_MODULE
4959 * @uses VISIBLEGROUPS
4960 * @param object $forum forum object
4961 * @param object $discussion
4962 * @param object $user
4963 * @param object $cm
4964 * @param object $course
4965 * @param object $context
4966 * @return bool
4967 */
4968 function forum_user_can_post($forum, $discussion, $user=NULL, $cm=NULL, $course=NULL, $context=NULL) {
4969 global $USER, $DB;
4970 if (empty($user)) {
4971 $user = $USER;
4972 }
4973
4974 // shortcut - guest and not-logged-in users can not post
4975 if (isguestuser($user) or empty($user->id)) {
4976 return false;
4977 }
4978
4979 if (!isset($discussion->groupid)) {
4980 debugging('incorrect discussion parameter', DEBUG_DEVELOPER);
4981 return false;
4982 }
4983
4984 if (!$cm) {
4985 debugging('missing cm', DEBUG_DEVELOPER);
4986 if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
4987 print_error('invalidcoursemodule');
4988 }
4989 }
4990
4991 if (!$course) {
4992 debugging('missing course', DEBUG_DEVELOPER);
4993 if (!$course = $DB->get_record('course', array('id' => $forum->course))) {
4994 print_error('invalidcourseid');
4995 }
4996 }
4997
4998 if (!$context) {
4999 $context = context_module::instance($cm->id);
5000 }
5001
5002 // normal users with temporary guest access can not post, suspended users can not post either
5003 if (!is_viewing($context, $user->id) and !is_enrolled($context, $user->id, '', true)) {
5004 return false;
5005 }
5006
5007 if ($forum->type == 'news') {
5008 $capname = 'mod/forum:replynews';
5009 } else {
5010 $capname = 'mod/forum:replypost';
5011 }
5012
5013 if (!has_capability($capname, $context, $user->id)) {
5014 return false;
5015 }
5016
5017 if (!$groupmode = groups_get_activity_groupmode($cm, $course)) {
5018 return true;
5019 }
5020
5021 if (has_capability('moodle/site:accessallgroups', $context)) {
5022 return true;
5023 }
5024
5025 if ($groupmode == VISIBLEGROUPS) {
5026 if ($discussion->groupid == -1) {
5027 // allow students to reply to all participants discussions - this was not possible in Moodle <1.8
5028 return true;
5029 }
5030 return groups_is_member($discussion->groupid);
5031
5032 } else {
5033 //separate groups
5034 if ($discussion->groupid == -1) {
5035 return false;
5036 }
5037 return groups_is_member($discussion->groupid);
5038 }
5039 }
5040
5041 /**
5042 * Check to ensure a user can view a timed discussion.
5043 *
5044 * @param object $discussion
5045 * @param object $user
5046 * @param object $context
5047 * @return boolean returns true if they can view post, false otherwise
5048 */
5049 function forum_user_can_see_timed_discussion($discussion, $user, $context) {
5050 global $CFG;
5051
5052 // Check that the user can view a discussion that is normally hidden due to access times.
5053 if (!empty($CFG->forum_enabletimedposts)) {
5054 $time = time();
5055 if (($discussion->timestart != 0 && $discussion->timestart > $time)
5056 || ($discussion->timeend != 0 && $discussion->timeend < $time)) {
5057 if (!has_capability('mod/forum:viewhiddentimedposts', $context, $user->id)) {
5058 return false;
5059 }
5060 }
5061 }
5062
5063 return true;
5064 }
5065
5066 /**
5067 * Check to ensure a user can view a group discussion.
5068 *
5069 * @param object $discussion
5070 * @param object $cm
5071 * @param object $context
5072 * @return boolean returns true if they can view post, false otherwise
5073 */
5074 function forum_user_can_see_group_discussion($discussion, $cm, $context) {
5075
5076 // If it's a grouped discussion, make sure the user is a member.
5077 if ($discussion->groupid > 0) {
5078 $groupmode = groups_get_activity_groupmode($cm);
5079 if ($groupmode == SEPARATEGROUPS) {
5080 return groups_is_member($discussion->groupid) || has_capability('moodle/site:accessallgroups', $context);
5081 }
5082 }
5083
5084 return true;
5085 }
5086
5087 /**
5088 * @global object
5089 * @global object
5090 * @uses DEBUG_DEVELOPER
5091 * @param object $forum
5092 * @param object $discussion
5093 * @param object $context
5094 * @param object $user
5095 * @return bool
5096 */
5097 function forum_user_can_see_discussion($forum, $discussion, $context, $user=NULL) {
5098 global $USER, $DB;
5099
5100 if (empty($user) || empty($user->id)) {
5101 $user = $USER;
5102 }
5103
5104 // retrieve objects (yuk)
5105 if (is_numeric($forum)) {
5106 debugging('missing full forum', DEBUG_DEVELOPER);
5107 if (!$forum = $DB->get_record('forum',array('id'=>$forum))) {
5108 return false;
5109 }
5110 }
5111 if (is_numeric($discussion)) {
5112 debugging('missing full discussion', DEBUG_DEVELOPER);
5113 if (!$discussion = $DB->get_record('forum_discussions',array('id'=>$discussion))) {
5114 return false;
5115 }
5116 }
5117 if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
5118 print_error('invalidcoursemodule');
5119 }
5120
5121 if (!has_capability('mod/forum:viewdiscussion', $context)) {
5122 return false;
5123 }
5124
5125 if (!forum_user_can_see_timed_discussion($discussion, $user, $context)) {
5126 return false;
5127 }
5128
5129 if (!forum_user_can_see_group_discussion($discussion, $cm, $context)) {
5130 return false;
5131 }
5132
5133 if ($forum->type == 'qanda' &&
5134 !forum_user_has_posted($forum->id, $discussion->id, $user->id) &&
5135 !has_capability('mod/forum:viewqandawithoutposting', $context)) {
5136 return false;
5137 }
5138 return true;
5139 }
5140
5141 /**
5142 * @global object
5143 * @global object
5144 * @param object $forum
5145 * @param object $discussion
5146 * @param object $post
5147 * @param object $user
5148 * @param object $cm
5149 * @return bool
5150 */
5151 function forum_user_can_see_post($forum, $discussion, $post, $user=NULL, $cm=NULL) {
5152 global $CFG, $USER, $DB;
5153
5154 // Context used throughout function.
5155 $modcontext = context_module::instance($cm->id);
5156
5157 // retrieve objects (yuk)
5158 if (is_numeric($forum)) {
5159 debugging('missing full forum', DEBUG_DEVELOPER);
5160 if (!$forum = $DB->get_record('forum',array('id'=>$forum))) {
5161 return false;
5162 }
5163 }
5164
5165 if (is_numeric($discussion)) {
5166 debugging('missing full discussion', DEBUG_DEVELOPER);
5167 if (!$discussion = $DB->get_record('forum_discussions',array('id'=>$discussion))) {
5168 return false;
5169 }
5170 }
5171 if (is_numeric($post)) {
5172 debugging('missing full post', DEBUG_DEVELOPER);
5173 if (!$post = $DB->get_record('forum_posts',array('id'=>$post))) {
5174 return false;
5175 }
5176 }
5177
5178 if (!isset($post->id) && isset($post->parent)) {
5179 $post->id = $post->parent;
5180 }
5181
5182 if (!$cm) {
5183 debugging('missing cm', DEBUG_DEVELOPER);
5184 if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
5185 print_error('invalidcoursemodule');
5186 }
5187 }
5188
5189 if (empty($user) || empty($user->id)) {
5190 $user = $USER;
5191 }
5192
5193 $canviewdiscussion = !empty($cm->cache->caps['mod/forum:viewdiscussion']) || has_capability('mod/forum:viewdiscussion', $modcontext, $user->id);
5194 if (!$canviewdiscussion && !has_all_capabilities(array('moodle/user:viewdetails', 'moodle/user:readuserposts'), context_user::instance($post->userid))) {
5195 return false;
5196 }
5197
5198 if (isset($cm->uservisible)) {
5199 if (!$cm->uservisible) {
5200 return false;
5201 }
5202 } else {
5203 if (!\core_availability\info_module::is_user_visible($cm, $user->id, false)) {
5204 return false;
5205 }
5206 }
5207
5208 if (!forum_user_can_see_timed_discussion($discussion, $user, $modcontext)) {
5209 return false;
5210 }
5211
5212 if (!forum_user_can_see_group_discussion($discussion, $cm, $modcontext)) {
5213 return false;
5214 }
5215
5216 if ($forum->type == 'qanda') {
5217 $firstpost = forum_get_firstpost_from_discussion($discussion->id);
5218 $userfirstpost = forum_get_user_posted_time($discussion->id, $user->id);
5219
5220 return (($userfirstpost !== false && (time() - $userfirstpost >= $CFG->maxeditingtime)) ||
5221 $firstpost->id == $post->id || $post->userid == $user->id || $firstpost->userid == $user->id ||
5222 has_capability('mod/forum:viewqandawithoutposting', $modcontext, $user->id));
5223 }
5224 return true;
5225 }
5226
5227
5228 /**
5229 * Prints the discussion view screen for a forum.
5230 *
5231 * @global object
5232 * @global object
5233 * @param object $course The current course object.
5234 * @param object $forum Forum to be printed.
5235 * @param int $maxdiscussions .
5236 * @param string $displayformat The display format to use (optional).
5237 * @param string $sort Sort arguments for database query (optional).
5238 * @param int $groupmode Group mode of the forum (optional).
5239 * @param void $unused (originally current group)
5240 * @param int $page Page mode, page to display (optional).
5241 * @param int $perpage The maximum number of discussions per page(optional)
5242 * @param boolean $subscriptionstatus Whether the user is currently subscribed to the discussion in some fashion.
5243 *
5244 */
5245 function forum_print_latest_discussions($course, $forum, $maxdiscussions = -1, $displayformat = 'plain', $sort = '',
5246 $currentgroup = -1, $groupmode = -1, $page = -1, $perpage = 100, $cm = null) {
5247 global $CFG, $USER, $OUTPUT;
5248
5249 if (!$cm) {
5250 if (!$cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course)) {
5251 print_error('invalidcoursemodule');
5252 }
5253 }
5254 $context = context_module::instance($cm->id);
5255
5256 if (empty($sort)) {
5257 $sort = "d.timemodified DESC";
5258 }
5259
5260 $olddiscussionlink = false;
5261
5262 // Sort out some defaults
5263 if ($perpage <= 0) {
5264 $perpage = 0;
5265 $page = -1;
5266 }
5267
5268 if ($maxdiscussions == 0) {
5269 // all discussions - backwards compatibility
5270 $page = -1;
5271 $perpage = 0;
5272 if ($displayformat == 'plain') {
5273 $displayformat = 'header'; // Abbreviate display by default
5274 }
5275
5276 } else if ($maxdiscussions > 0) {
5277 $page = -1;
5278 $perpage = $maxdiscussions;
5279 }
5280
5281 $fullpost = false;
5282 if ($displayformat == 'plain') {
5283 $fullpost = true;
5284 }
5285
5286
5287 // Decide if current user is allowed to see ALL the current discussions or not
5288
5289 // First check the group stuff
5290 if ($currentgroup == -1 or $groupmode == -1) {
5291 $groupmode = groups_get_activity_groupmode($cm, $course);
5292 $currentgroup = groups_get_activity_group($cm);
5293 }
5294
5295 $groups = array(); //cache
5296
5297 // If the user can post discussions, then this is a good place to put the
5298 // button for it. We do not show the button if we are showing site news
5299 // and the current user is a guest.
5300
5301 $canstart = forum_user_can_post_discussion($forum, $currentgroup, $groupmode, $cm, $context);
5302 if (!$canstart and $forum->type !== 'news') {
5303 if (isguestuser() or !isloggedin()) {
5304 $canstart = true;
5305 }
5306 if (!is_enrolled($context) and !is_viewing($context)) {
5307 // allow guests and not-logged-in to see the button - they are prompted to log in after clicking the link
5308 // normal users with temporary guest access see this button too, they are asked to enrol instead
5309 // do not show the button to users with suspended enrolments here
5310 $canstart = enrol_selfenrol_available($course->id);
5311 }
5312 }
5313
5314 if ($canstart) {
5315 echo '<div class="singlebutton forumaddnew">';
5316 echo "<form id=\"newdiscussionform\" method=\"get\" action=\"$CFG->wwwroot/mod/forum/post.php\">";
5317 echo '<div>';
5318 echo "<input type=\"hidden\" name=\"forum\" value=\"$forum->id\" />";
5319 switch ($forum->type) {
5320 case 'news':
5321 case 'blog':
5322 $buttonadd = get_string('addanewtopic', 'forum');
5323 break;
5324 case 'qanda':
5325 $buttonadd = get_string('addanewquestion', 'forum');
5326 break;
5327 default:
5328 $buttonadd = get_string('addanewdiscussion', 'forum');
5329 break;
5330 }
5331 echo '<input type="submit" value="'.$buttonadd.'" />';
5332 echo '</div>';
5333 echo '</form>';
5334 echo "</div>\n";
5335
5336 } else if (isguestuser() or !isloggedin() or $forum->type == 'news' or
5337 $forum->type == 'qanda' and !has_capability('mod/forum:addquestion', $context) or
5338 $forum->type != 'qanda' and !has_capability('mod/forum:startdiscussion', $context)) {
5339 // no button and no info
5340
5341 } else if ($groupmode and !has_capability('moodle/site:accessallgroups', $context)) {
5342 // inform users why they can not post new discussion
5343 if (!$currentgroup) {
5344 echo $OUTPUT->notification(get_string('cannotadddiscussionall', 'forum'));
5345 } else if (!groups_is_member($currentgroup)) {
5346 echo $OUTPUT->notification(get_string('cannotadddiscussion', 'forum'));
5347 }
5348 }
5349
5350 // Get all the recent discussions we're allowed to see
5351
5352 $getuserlastmodified = ($displayformat == 'header');
5353
5354 if (! $discussions = forum_get_discussions($cm, $sort, $fullpost, null, $maxdiscussions, $getuserlastmodified, $page, $perpage) ) {
5355 echo '<div class="forumnodiscuss">';
5356 if ($forum->type == 'news') {
5357 echo '('.get_string('nonews', 'forum').')';
5358 } else if ($forum->type == 'qanda') {
5359 echo '('.get_string('noquestions','forum').')';
5360 } else {
5361 echo '('.get_string('nodiscussions', 'forum').')';
5362 }
5363 echo "</div>\n";
5364 return;
5365 }
5366
5367 // If we want paging
5368 if ($page != -1) {
5369 ///Get the number of discussions found
5370 $numdiscussions = forum_get_discussions_count($cm);
5371
5372 ///Show the paging bar
5373 echo $OUTPUT->paging_bar($numdiscussions, $page, $perpage, "view.php?f=$forum->id");
5374 if ($numdiscussions > 1000) {
5375 // saves some memory on sites with very large forums
5376 $replies = forum_count_discussion_replies($forum->id, $sort, $maxdiscussions, $page, $perpage);
5377 } else {
5378 $replies = forum_count_discussion_replies($forum->id);
5379 }
5380
5381 } else {
5382 $replies = forum_count_discussion_replies($forum->id);
5383
5384 if ($maxdiscussions > 0 and $maxdiscussions <= count($discussions)) {
5385 $olddiscussionlink = true;
5386 }
5387 }
5388
5389 $canviewparticipants = has_capability('moodle/course:viewparticipants',$context);
5390
5391 $strdatestring = get_string('strftimerecentfull');
5392
5393 // Check if the forum is tracked.
5394 if ($cantrack = forum_tp_can_track_forums($forum)) {
5395 $forumtracked = forum_tp_is_tracked($forum);
5396 } else {
5397 $forumtracked = false;
5398 }
5399
5400 if ($forumtracked) {
5401 $unreads = forum_get_discussions_unread($cm);
5402 } else {
5403 $unreads = array();
5404 }
5405
5406 if ($displayformat == 'header') {
5407 echo '<table cellspacing="0" class="forumheaderlist">';
5408 echo '<thead>';
5409 echo '<tr>';
5410 echo '<th class="header topic" scope="col">'.get_string('discussion', 'forum').'</th>';
5411 echo '<th class="header author" colspan="2" scope="col">'.get_string('startedby', 'forum').'</th>';
5412 if ($groupmode > 0) {
5413 echo '<th class="header group" scope="col">'.get_string('group').'</th>';
5414 }
5415 if (has_capability('mod/forum:viewdiscussion', $context)) {
5416 echo '<th class="header replies" scope="col">'.get_string('replies', 'forum').'</th>';
5417 // If the forum can be tracked, display the unread column.
5418 if ($cantrack) {
5419 echo '<th class="header replies" scope="col">'.get_string('unread', 'forum');
5420 if ($forumtracked) {
5421 echo '<a title="'.get_string('markallread', 'forum').
5422 '" href="'.$CFG->wwwroot.'/mod/forum/markposts.php?f='.
5423 $forum->id.'&amp;mark=read&amp;returnpage=view.php">'.
5424 '<img src="'.$OUTPUT->pix_url('t/markasread') . '" class="iconsmall" alt="'.get_string('markallread', 'forum').'" /></a>';
5425 }
5426 echo '</th>';
5427 }
5428 }
5429 echo '<th class="header lastpost" scope="col">'.get_string('lastpost', 'forum').'</th>';
5430 if ((!is_guest($context, $USER) && isloggedin()) && has_capability('mod/forum:viewdiscussion', $context)) {
5431 if (\mod_forum\subscriptions::is_subscribable($forum)) {
5432 echo '<th class="header discussionsubscription" scope="col">';
5433 echo forum_get_discussion_subscription_icon_preloaders();
5434 echo '</th>';
5435 }
5436 }
5437 echo '</tr>';
5438 echo '</thead>';
5439 echo '<tbody>';
5440 }
5441
5442 foreach ($discussions as $discussion) {
5443 if ($forum->type == 'qanda' && !has_capability('mod/forum:viewqandawithoutposting', $context) &&
5444 !forum_user_has_posted($forum->id, $discussion->discussion, $USER->id)) {
5445 $canviewparticipants = false;
5446 }
5447
5448 if (!empty($replies[$discussion->discussion])) {
5449 $discussion->replies = $replies[$discussion->discussion]->replies;
5450 $discussion->lastpostid = $replies[$discussion->discussion]->lastpostid;
5451 } else {
5452 $discussion->replies = 0;
5453 }
5454
5455 // SPECIAL CASE: The front page can display a news item post to non-logged in users.
5456 // All posts are read in this case.
5457 if (!$forumtracked) {
5458 $discussion->unread = '-';
5459 } else if (empty($USER)) {
5460 $discussion->unread = 0;
5461 } else {
5462 if (empty($unreads[$discussion->discussion])) {
5463 $discussion->unread = 0;
5464 } else {
5465 $discussion->unread = $unreads[$discussion->discussion];
5466 }
5467 }
5468
5469 if (isloggedin()) {
5470 $ownpost = ($discussion->userid == $USER->id);
5471 } else {
5472 $ownpost=false;
5473 }
5474 // Use discussion name instead of subject of first post
5475 $discussion->subject = $discussion->name;
5476
5477 switch ($displayformat) {
5478 case 'header':
5479 if ($groupmode > 0) {
5480 if (isset($groups[$discussion->groupid])) {
5481 $group = $groups[$discussion->groupid];
5482 } else {
5483 $group = $groups[$discussion->groupid] = groups_get_group($discussion->groupid);
5484 }
5485 } else {
5486 $group = -1;
5487 }
5488 forum_print_discussion_header($discussion, $forum, $group, $strdatestring, $cantrack, $forumtracked,
5489 $canviewparticipants, $context);
5490 break;
5491 default:
5492 $link = false;
5493
5494 if ($discussion->replies) {
5495 $link = true;
5496 } else {
5497 $modcontext = context_module::instance($cm->id);
5498 $link = forum_user_can_see_discussion($forum, $discussion, $modcontext, $USER);
5499 }
5500
5501 $discussion->forum = $forum->id;
5502
5503 forum_print_post($discussion, $discussion, $forum, $cm, $course, $ownpost, 0, $link, false,
5504 '', null, true, $forumtracked);
5505 break;
5506 }
5507 }
5508
5509 if ($displayformat == "header") {
5510 echo '</tbody>';
5511 echo '</table>';
5512 }
5513
5514 if ($olddiscussionlink) {
5515 if ($forum->type == 'news') {
5516 $strolder = get_string('oldertopics', 'forum');
5517 } else {
5518 $strolder = get_string('olderdiscussions', 'forum');
5519 }
5520 echo '<div class="forumolddiscuss">';
5521 echo '<a href="'.$CFG->wwwroot.'/mod/forum/view.php?f='.$forum->id.'&amp;showall=1">';
5522 echo $strolder.'</a> ...</div>';
5523 }
5524
5525 if ($page != -1) { ///Show the paging bar
5526 echo $OUTPUT->paging_bar($numdiscussions, $page, $perpage, "view.php?f=$forum->id");
5527 }
5528 }
5529
5530
5531 /**
5532 * Prints a forum discussion
5533 *
5534 * @uses CONTEXT_MODULE
5535 * @uses FORUM_MODE_FLATNEWEST
5536 * @uses FORUM_MODE_FLATOLDEST
5537 * @uses FORUM_MODE_THREADED
5538 * @uses FORUM_MODE_NESTED
5539 * @param stdClass $course
5540 * @param stdClass $cm
5541 * @param stdClass $forum
5542 * @param stdClass $discussion
5543 * @param stdClass $post
5544 * @param int $mode
5545 * @param mixed $canreply
5546 * @param bool $canrate
5547 */
5548 function forum_print_discussion($course, $cm, $forum, $discussion, $post, $mode, $canreply=NULL, $canrate=false) {
5549 global $USER, $CFG;
5550
5551 require_once($CFG->dirroot.'/rating/lib.php');
5552
5553 $ownpost = (isloggedin() && $USER->id == $post->userid);
5554
5555 $modcontext = context_module::instance($cm->id);
5556 if ($canreply === NULL) {
5557 $reply = forum_user_can_post($forum, $discussion, $USER, $cm, $course, $modcontext);
5558 } else {
5559 $reply = $canreply;
5560 }
5561
5562 // $cm holds general cache for forum functions
5563 $cm->cache = new stdClass;
5564 $cm->cache->groups = groups_get_all_groups($course->id, 0, $cm->groupingid);
5565 $cm->cache->usersgroups = array();
5566
5567 $posters = array();
5568
5569 // preload all posts - TODO: improve...
5570 if ($mode == FORUM_MODE_FLATNEWEST) {
5571 $sort = "p.created DESC";
5572 } else {
5573 $sort = "p.created ASC";
5574 }
5575
5576 $forumtracked = forum_tp_is_tracked($forum);
5577 $posts = forum_get_all_discussion_posts($discussion->id, $sort, $forumtracked);
5578 $post = $posts[$post->id];
5579
5580 foreach ($posts as $pid=>$p) {
5581 $posters[$p->userid] = $p->userid;
5582 }
5583
5584 // preload all groups of ppl that posted in this discussion
5585 if ($postersgroups = groups_get_all_groups($course->id, $posters, $cm->groupingid, 'gm.id, gm.groupid, gm.userid')) {
5586 foreach($postersgroups as $pg) {
5587 if (!isset($cm->cache->usersgroups[$pg->userid])) {
5588 $cm->cache->usersgroups[$pg->userid] = array();
5589 }
5590 $cm->cache->usersgroups[$pg->userid][$pg->groupid] = $pg->groupid;
5591 }
5592 unset($postersgroups);
5593 }
5594
5595 //load ratings
5596 if ($forum->assessed != RATING_AGGREGATE_NONE) {
5597 $ratingoptions = new stdClass;
5598 $ratingoptions->context = $modcontext;
5599 $ratingoptions->component = 'mod_forum';
5600 $ratingoptions->ratingarea = 'post';
5601 $ratingoptions->items = $posts;
5602 $ratingoptions->aggregate = $forum->assessed;//the aggregation method
5603 $ratingoptions->scaleid = $forum->scale;
5604 $ratingoptions->userid = $USER->id;
5605 if ($forum->type == 'single' or !$discussion->id) {
5606 $ratingoptions->returnurl = "$CFG->wwwroot/mod/forum/view.php?id=$cm->id";
5607 } else {
5608 $ratingoptions->returnurl = "$CFG->wwwroot/mod/forum/discuss.php?d=$discussion->id";
5609 }
5610 $ratingoptions->assesstimestart = $forum->assesstimestart;
5611 $ratingoptions->assesstimefinish = $forum->assesstimefinish;
5612
5613 $rm = new rating_manager();
5614 $posts = $rm->get_ratings($ratingoptions);
5615 }
5616
5617
5618 $post->forum = $forum->id; // Add the forum id to the post object, later used by forum_print_post
5619 $post->forumtype = $forum->type;
5620
5621 $post->subject = format_string($post->subject);
5622
5623 $postread = !empty($post->postread);
5624
5625 forum_print_post($post, $discussion, $forum, $cm, $course, $ownpost, $reply, false,
5626 '', '', $postread, true, $forumtracked);
5627
5628 switch ($mode) {
5629 case FORUM_MODE_FLATOLDEST :
5630 case FORUM_MODE_FLATNEWEST :
5631 default:
5632 forum_print_posts_flat($course, $cm, $forum, $discussion, $post, $mode, $reply, $forumtracked, $posts);
5633 break;
5634
5635 case FORUM_MODE_THREADED :
5636 forum_print_posts_threaded($course, $cm, $forum, $discussion, $post, 0, $reply, $forumtracked, $posts);
5637 break;
5638
5639 case FORUM_MODE_NESTED :
5640 forum_print_posts_nested($course, $cm, $forum, $discussion, $post, $reply, $forumtracked, $posts);
5641 break;
5642 }
5643 }
5644
5645
5646 /**
5647 * @global object
5648 * @global object
5649 * @uses FORUM_MODE_FLATNEWEST
5650 * @param object $course
5651 * @param object $cm
5652 * @param object $forum
5653 * @param object $discussion
5654 * @param object $post
5655 * @param object $mode
5656 * @param bool $reply
5657 * @param bool $forumtracked
5658 * @param array $posts
5659 * @return void
5660 */
5661 function forum_print_posts_flat($course, &$cm, $forum, $discussion, $post, $mode, $reply, $forumtracked, $posts) {
5662 global $USER, $CFG;
5663
5664 $link = false;
5665
5666 if ($mode == FORUM_MODE_FLATNEWEST) {
5667 $sort = "ORDER BY created DESC";
5668 } else {
5669 $sort = "ORDER BY created ASC";
5670 }
5671
5672 foreach ($posts as $post) {
5673 if (!$post->parent) {
5674 continue;
5675 }
5676 $post->subject = format_string($post->subject);
5677 $ownpost = ($USER->id == $post->userid);
5678
5679 $postread = !empty($post->postread);
5680
5681 forum_print_post($post, $discussion, $forum, $cm, $course, $ownpost, $reply, $link,
5682 '', '', $postread, true, $forumtracked);
5683 }
5684 }
5685
5686 /**
5687 * @todo Document this function
5688 *
5689 * @global object
5690 * @global object
5691 * @uses CONTEXT_MODULE
5692 * @return void
5693 */
5694 function forum_print_posts_threaded($course, &$cm, $forum, $discussion, $parent, $depth, $reply, $forumtracked, $posts) {
5695 global $USER, $CFG;
5696
5697 $link = false;
5698
5699 if (!empty($posts[$parent->id]->children)) {
5700 $posts = $posts[$parent->id]->children;
5701
5702 $modcontext = context_module::instance($cm->id);
5703 $canviewfullnames = has_capability('moodle/site:viewfullnames', $modcontext);
5704
5705 foreach ($posts as $post) {
5706
5707 echo '<div class="indent">';
5708 if ($depth > 0) {
5709 $ownpost = ($USER->id == $post->userid);
5710 $post->subject = format_string($post->subject);
5711
5712 $postread = !empty($post->postread);
5713
5714 forum_print_post($post, $discussion, $forum, $cm, $course, $ownpost, $reply, $link,
5715 '', '', $postread, true, $forumtracked);
5716 } else {
5717 if (!forum_user_can_see_post($forum, $discussion, $post, NULL, $cm)) {
5718 echo "</div>\n";
5719 continue;
5720 }
5721 $by = new stdClass();
5722 $by->name = fullname($post, $canviewfullnames);
5723 $by->date = userdate($post->modified);
5724
5725 if ($forumtracked) {
5726 if (!empty($post->postread)) {
5727 $style = '<span class="forumthread read">';
5728 } else {
5729 $style = '<span class="forumthread unread">';
5730 }
5731 } else {
5732 $style = '<span class="forumthread">';
5733 }
5734 echo $style."<a name=\"$post->id\"></a>".
5735 "<a href=\"discuss.php?d=$post->discussion&amp;parent=$post->id\">".format_string($post->subject,true)."</a> ";
5736 print_string("bynameondate", "forum", $by);
5737 echo "</span>";
5738 }
5739
5740 forum_print_posts_threaded($course, $cm, $forum, $discussion, $post, $depth-1, $reply, $forumtracked, $posts);
5741 echo "</div>\n";
5742 }
5743 }
5744 }
5745
5746 /**
5747 * @todo Document this function
5748 * @global object
5749 * @global object
5750 * @return void
5751 */
5752 function forum_print_posts_nested($course, &$cm, $forum, $discussion, $parent, $reply, $forumtracked, $posts) {
5753 global $USER, $CFG;
5754
5755 $link = false;
5756
5757 if (!empty($posts[$parent->id]->children)) {
5758 $posts = $posts[$parent->id]->children;
5759
5760 foreach ($posts as $post) {
5761
5762 echo '<div class="indent">';
5763 if (!isloggedin()) {
5764 $ownpost = false;
5765 } else {
5766 $ownpost = ($USER->id == $post->userid);
5767 }
5768
5769 $post->subject = format_string($post->subject);
5770 $postread = !empty($post->postread);
5771
5772 forum_print_post($post, $discussion, $forum, $cm, $course, $ownpost, $reply, $link,
5773 '', '', $postread, true, $forumtracked);
5774 forum_print_posts_nested($course, $cm, $forum, $discussion, $post, $reply, $forumtracked, $posts);
5775 echo "</div>\n";
5776 }
5777 }
5778 }
5779
5780 /**
5781 * Returns all forum posts since a given time in specified forum.
5782 *
5783 * @todo Document this functions args
5784 * @global object
5785 * @global object
5786 * @global object
5787 * @global object
5788 */
5789 function forum_get_recent_mod_activity(&$activities, &$index, $timestart, $courseid, $cmid, $userid=0, $groupid=0) {
5790 global $CFG, $COURSE, $USER, $DB;
5791
5792 if ($COURSE->id == $courseid) {
5793 $course = $COURSE;
5794 } else {
5795 $course = $DB->get_record('course', array('id' => $courseid));
5796 }
5797
5798 $modinfo = get_fast_modinfo($course);
5799
5800 $cm = $modinfo->cms[$cmid];
5801 $params = array($timestart, $cm->instance);
5802
5803 if ($userid) {
5804 $userselect = "AND u.id = ?";
5805 $params[] = $userid;
5806 } else {
5807 $userselect = "";
5808 }
5809
5810 if ($groupid) {
5811 $groupselect = "AND d.groupid = ?";
5812 $params[] = $groupid;
5813 } else {
5814 $groupselect = "";
5815 }
5816
5817 $allnames = get_all_user_name_fields(true, 'u');
5818 if (!$posts = $DB->get_records_sql("SELECT p.*, f.type AS forumtype, d.forum, d.groupid,
5819 d.timestart, d.timeend, d.userid AS duserid,
5820 $allnames, u.email, u.picture, u.imagealt, u.email
5821 FROM {forum_posts} p
5822 JOIN {forum_discussions} d ON d.id = p.discussion
5823 JOIN {forum} f ON f.id = d.forum
5824 JOIN {user} u ON u.id = p.userid
5825 WHERE p.created > ? AND f.id = ?
5826 $userselect $groupselect
5827 ORDER BY p.id ASC", $params)) { // order by initial posting date
5828 return;
5829 }
5830
5831 $groupmode = groups_get_activity_groupmode($cm, $course);
5832 $cm_context = context_module::instance($cm->id);
5833 $viewhiddentimed = has_capability('mod/forum:viewhiddentimedposts', $cm_context);
5834 $accessallgroups = has_capability('moodle/site:accessallgroups', $cm_context);
5835
5836 $printposts = array();
5837 foreach ($posts as $post) {
5838
5839 if (!empty($CFG->forum_enabletimedposts) and $USER->id != $post->duserid
5840 and (($post->timestart > 0 and $post->timestart > time()) or ($post->timeend > 0 and $post->timeend < time()))) {
5841 if (!$viewhiddentimed) {
5842 continue;
5843 }
5844 }
5845
5846 if ($groupmode) {
5847 if ($post->groupid == -1 or $groupmode == VISIBLEGROUPS or $accessallgroups) {
5848 // oki (Open discussions have groupid -1)
5849 } else {
5850 // separate mode
5851 if (isguestuser()) {
5852 // shortcut
5853 continue;
5854 }
5855
5856 if (!in_array($post->groupid, $modinfo->get_groups($cm->groupingid))) {
5857 continue;
5858 }
5859 }
5860 }
5861
5862 $printposts[] = $post;
5863 }
5864
5865 if (!$printposts) {
5866 return;
5867 }
5868
5869 $aname = format_string($cm->name,true);
5870
5871 foreach ($printposts as $post) {
5872 $tmpactivity = new stdClass();
5873
5874 $tmpactivity->type = 'forum';
5875 $tmpactivity->cmid = $cm->id;
5876 $tmpactivity->name = $aname;
5877 $tmpactivity->sectionnum = $cm->sectionnum;
5878 $tmpactivity->timestamp = $post->modified;
5879
5880 $tmpactivity->content = new stdClass();
5881 $tmpactivity->content->id = $post->id;
5882 $tmpactivity->content->discussion = $post->discussion;
5883 $tmpactivity->content->subject = format_string($post->subject);
5884 $tmpactivity->content->parent = $post->parent;
5885
5886 $tmpactivity->user = new stdClass();
5887 $additionalfields = array('id' => 'userid', 'picture', 'imagealt', 'email');
5888 $additionalfields = explode(',', user_picture::fields());
5889 $tmpactivity->user = username_load_fields_from_object($tmpactivity->user, $post, null, $additionalfields);
5890 $tmpactivity->user->id = $post->userid;
5891
5892 $activities[$index++] = $tmpactivity;
5893 }
5894
5895 return;
5896 }
5897
5898 /**
5899 * @todo Document this function
5900 * @global object
5901 */
5902 function forum_print_recent_mod_activity($activity, $courseid, $detail, $modnames, $viewfullnames) {
5903 global $CFG, $OUTPUT;
5904
5905 if ($activity->content->parent) {
5906 $class = 'reply';
5907 } else {
5908 $class = 'discussion';
5909 }
5910
5911 echo '<table border="0" cellpadding="3" cellspacing="0" class="forum-recent">';
5912
5913 echo "<tr><td class=\"userpicture\" valign=\"top\">";
5914 echo $OUTPUT->user_picture($activity->user, array('courseid'=>$courseid));
5915 echo "</td><td class=\"$class\">";
5916
5917 if ($activity->content->parent) {
5918 $class = 'title';
5919 } else {
5920 // Bold the title of new discussions so they stand out.
5921 $class = 'title bold';
5922 }
5923 echo "<div class=\"{$class}\">";
5924 if ($detail) {
5925 $aname = s($activity->name);
5926 echo "<img src=\"" . $OUTPUT->pix_url('icon', $activity->type) . "\" ".
5927 "class=\"icon\" alt=\"{$aname}\" />";
5928 }
5929 echo "<a href=\"$CFG->wwwroot/mod/forum/discuss.php?d={$activity->content->discussion}"
5930 ."#p{$activity->content->id}\">{$activity->content->subject}</a>";
5931 echo '</div>';
5932
5933 echo '<div class="user">';
5934 $fullname = fullname($activity->user, $viewfullnames);
5935 echo "<a href=\"$CFG->wwwroot/user/view.php?id={$activity->user->id}&amp;course=$courseid\">"
5936 ."{$fullname}</a> - ".userdate($activity->timestamp);
5937 echo '</div>';
5938 echo "</td></tr></table>";
5939
5940 return;
5941 }
5942
5943 /**
5944 * recursively sets the discussion field to $discussionid on $postid and all its children
5945 * used when pruning a post
5946 *
5947 * @global object
5948 * @param int $postid
5949 * @param int $discussionid
5950 * @return bool
5951 */
5952 function forum_change_discussionid($postid, $discussionid) {
5953 global $DB;
5954 $DB->set_field('forum_posts', 'discussion', $discussionid, array('id' => $postid));
5955 if ($posts = $DB->get_records('forum_posts', array('parent' => $postid))) {
5956 foreach ($posts as $post) {
5957 forum_change_discussionid($post->id, $discussionid);
5958 }
5959 }
5960 return true;
5961 }
5962
5963 /**
5964 * Prints the editing button on subscribers page
5965 *
5966 * @global object
5967 * @global object
5968 * @param int $courseid
5969 * @param int $forumid
5970 * @return string
5971 */
5972 function forum_update_subscriptions_button($courseid, $forumid) {
5973 global $CFG, $USER;
5974
5975 if (!empty($USER->subscriptionsediting)) {
5976 $string = get_string('turneditingoff');
5977 $edit = "off";
5978 } else {
5979 $string = get_string('turneditingon');
5980 $edit = "on";
5981 }
5982
5983 return "<form method=\"get\" action=\"$CFG->wwwroot/mod/forum/subscribers.php\">".
5984 "<input type=\"hidden\" name=\"id\" value=\"$forumid\" />".
5985 "<input type=\"hidden\" name=\"edit\" value=\"$edit\" />".
5986 "<input type=\"submit\" value=\"$string\" /></form>";
5987 }
5988
5989 // Functions to do with read tracking.
5990
5991 /**
5992 * Mark posts as read.
5993 *
5994 * @global object
5995 * @global object
5996 * @param object $user object
5997 * @param array $postids array of post ids
5998 * @return boolean success
5999 */
6000 function forum_tp_mark_posts_read($user, $postids) {
6001 global $CFG, $DB;
6002
6003 if (!forum_tp_can_track_forums(false, $user)) {
6004 return true;
6005 }
6006
6007 $status = true;
6008
6009 $now = time();
6010 $cutoffdate = $now - ($CFG->forum_oldpostdays * 24 * 3600);
6011
6012 if (empty($postids)) {
6013 return true;
6014
6015 } else if (count($postids) > 200) {
6016 while ($part = array_splice($postids, 0, 200)) {
6017 $status = forum_tp_mark_posts_read($user, $part) && $status;
6018 }
6019 return $status;
6020 }
6021
6022 list($usql, $postidparams) = $DB->get_in_or_equal($postids, SQL_PARAMS_NAMED, 'postid');
6023
6024 $insertparams = array(
6025 'userid1' => $user->id,
6026 'userid2' => $user->id,
6027 'userid3' => $user->id,
6028 'firstread' => $now,
6029 'lastread' => $now,
6030 'cutoffdate' => $cutoffdate,
6031 );
6032 $params = array_merge($postidparams, $insertparams);
6033
6034 if ($CFG->forum_allowforcedreadtracking) {
6035 $trackingsql = "AND (f.trackingtype = ".FORUM_TRACKING_FORCED."
6036 OR (f.trackingtype = ".FORUM_TRACKING_OPTIONAL." AND tf.id IS NULL))";
6037 } else {
6038 $trackingsql = "AND ((f.trackingtype = ".FORUM_TRACKING_OPTIONAL." OR f.trackingtype = ".FORUM_TRACKING_FORCED.")
6039 AND tf.id IS NULL)";
6040 }
6041
6042 // First insert any new entries.
6043 $sql = "INSERT INTO {forum_read} (userid, postid, discussionid, forumid, firstread, lastread)
6044
6045 SELECT :userid1, p.id, p.discussion, d.forum, :firstread, :lastread
6046 FROM {forum_posts} p
6047 JOIN {forum_discussions} d ON d.id = p.discussion
6048 JOIN {forum} f ON f.id = d.forum
6049 LEFT JOIN {forum_track_prefs} tf ON (tf.userid = :userid2 AND tf.forumid = f.id)
6050 LEFT JOIN {forum_read} fr ON (
6051 fr.userid = :userid3
6052 AND fr.postid = p.id
6053 AND fr.discussionid = d.id
6054 AND fr.forumid = f.id
6055 )
6056 WHERE p.id $usql
6057 AND p.modified >= :cutoffdate
6058 $trackingsql
6059 AND fr.id IS NULL";
6060
6061 $status = $DB->execute($sql, $params) && $status;
6062
6063 // Then update all records.
6064 $updateparams = array(
6065 'userid' => $user->id,
6066 'lastread' => $now,
6067 );
6068 $params = array_merge($postidparams, $updateparams);
6069 $status = $DB->set_field_select('forum_read', 'lastread', $now, '
6070 userid = :userid
6071 AND lastread <> :lastread
6072 AND postid ' . $usql,
6073 $params) && $status;
6074
6075 return $status;
6076 }
6077
6078 /**
6079 * Mark post as read.
6080 * @global object
6081 * @global object
6082 * @param int $userid
6083 * @param int $postid
6084 */
6085 function forum_tp_add_read_record($userid, $postid) {
6086 global $CFG, $DB;
6087
6088 $now = time();
6089 $cutoffdate = $now - ($CFG->forum_oldpostdays * 24 * 3600);
6090
6091 if (!$DB->record_exists('forum_read', array('userid' => $userid, 'postid' => $postid))) {
6092 $sql = "INSERT INTO {forum_read} (userid, postid, discussionid, forumid, firstread, lastread)
6093
6094 SELECT ?, p.id, p.discussion, d.forum, ?, ?
6095 FROM {forum_posts} p
6096 JOIN {forum_discussions} d ON d.id = p.discussion
6097 WHERE p.id = ? AND p.modified >= ?";
6098 return $DB->execute($sql, array($userid, $now, $now, $postid, $cutoffdate));
6099
6100 } else {
6101 $sql = "UPDATE {forum_read}
6102 SET lastread = ?
6103 WHERE userid = ? AND postid = ?";
6104 return $DB->execute($sql, array($now, $userid, $userid));
6105 }
6106 }
6107
6108 /**
6109 * If its an old post, do nothing. If the record exists, the maintenance will clear it up later.
6110 *
6111 * @return bool
6112 */
6113 function forum_tp_mark_post_read($userid, $post, $forumid) {
6114 if (!forum_tp_is_post_old($post)) {
6115 return forum_tp_add_read_record($userid, $post->id);
6116 } else {
6117 return true;
6118 }
6119 }
6120
6121 /**
6122 * Marks a whole forum as read, for a given user
6123 *
6124 * @global object
6125 * @global object
6126 * @param object $user
6127 * @param int $forumid
6128 * @param int|bool $groupid
6129 * @return bool
6130 */
6131 function forum_tp_mark_forum_read($user, $forumid, $groupid=false) {
6132 global $CFG, $DB;
6133
6134 $cutoffdate = time() - ($CFG->forum_oldpostdays*24*60*60);
6135
6136 $groupsel = "";
6137 $params = array($user->id, $forumid, $cutoffdate);
6138
6139 if ($groupid !== false) {
6140 $groupsel = " AND (d.groupid = ? OR d.groupid = -1)";
6141 $params[] = $groupid;
6142 }
6143
6144 $sql = "SELECT p.id
6145 FROM {forum_posts} p
6146 LEFT JOIN {forum_discussions} d ON d.id = p.discussion
6147 LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = ?)
6148 WHERE d.forum = ?
6149 AND p.modified >= ? AND r.id is NULL
6150 $groupsel";
6151
6152 if ($posts = $DB->get_records_sql($sql, $params)) {
6153 $postids = array_keys($posts);
6154 return forum_tp_mark_posts_read($user, $postids);
6155 }
6156
6157 return true;
6158 }
6159
6160 /**
6161 * Marks a whole discussion as read, for a given user
6162 *
6163 * @global object
6164 * @global object
6165 * @param object $user
6166 * @param int $discussionid
6167 * @return bool
6168 */
6169 function forum_tp_mark_discussion_read($user, $discussionid) {
6170 global $CFG, $DB;
6171
6172 $cutoffdate = time() - ($CFG->forum_oldpostdays*24*60*60);
6173
6174 $sql = "SELECT p.id
6175 FROM {forum_posts} p
6176 LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = ?)
6177 WHERE p.discussion = ?
6178 AND p.modified >= ? AND r.id is NULL";
6179
6180 if ($posts = $DB->get_records_sql($sql, array($user->id, $discussionid, $cutoffdate))) {
6181 $postids = array_keys($posts);
6182 return forum_tp_mark_posts_read($user, $postids);
6183 }
6184
6185 return true;
6186 }
6187
6188 /**
6189 * @global object
6190 * @param int $userid
6191 * @param object $post
6192 */
6193 function forum_tp_is_post_read($userid, $post) {
6194 global $DB;
6195 return (forum_tp_is_post_old($post) ||
6196 $DB->record_exists('forum_read', array('userid' => $userid, 'postid' => $post->id)));
6197 }
6198
6199 /**
6200 * @global object
6201 * @param object $post
6202 * @param int $time Defautls to time()
6203 */
6204 function forum_tp_is_post_old($post, $time=null) {
6205 global $CFG;
6206
6207 if (is_null($time)) {
6208 $time = time();
6209 }
6210 return ($post->modified < ($time - ($CFG->forum_oldpostdays * 24 * 3600)));
6211 }
6212
6213 /**
6214 * Returns the count of records for the provided user and course.
6215 * Please note that group access is ignored!
6216 *
6217 * @global object
6218 * @global object
6219 * @param int $userid
6220 * @param int $courseid
6221 * @return array
6222 */
6223 function forum_tp_get_course_unread_posts($userid, $courseid) {
6224 global $CFG, $DB;
6225
6226 $now = round(time(), -2); // DB cache friendliness.
6227 $cutoffdate = $now - ($CFG->forum_oldpostdays * 24 * 60 * 60);
6228 $params = array($userid, $userid, $courseid, $cutoffdate, $userid);
6229
6230 if (!empty($CFG->forum_enabletimedposts)) {
6231 $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
6232 $params[] = $now;
6233 $params[] = $now;
6234 } else {
6235 $timedsql = "";
6236 }
6237
6238 if ($CFG->forum_allowforcedreadtracking) {
6239 $trackingsql = "AND (f.trackingtype = ".FORUM_TRACKING_FORCED."
6240 OR (f.trackingtype = ".FORUM_TRACKING_OPTIONAL." AND tf.id IS NULL
6241 AND (SELECT trackforums FROM {user} WHERE id = ?) = 1))";
6242 } else {
6243 $trackingsql = "AND ((f.trackingtype = ".FORUM_TRACKING_OPTIONAL." OR f.trackingtype = ".FORUM_TRACKING_FORCED.")
6244 AND tf.id IS NULL
6245 AND (SELECT trackforums FROM {user} WHERE id = ?) = 1)";
6246 }
6247
6248 $sql = "SELECT f.id, COUNT(p.id) AS unread
6249 FROM {forum_posts} p
6250 JOIN {forum_discussions} d ON d.id = p.discussion
6251 JOIN {forum} f ON f.id = d.forum
6252 JOIN {course} c ON c.id = f.course
6253 LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = ?)
6254 LEFT JOIN {forum_track_prefs} tf ON (tf.userid = ? AND tf.forumid = f.id)
6255 WHERE f.course = ?
6256 AND p.modified >= ? AND r.id is NULL
6257 $trackingsql
6258 $timedsql
6259 GROUP BY f.id";
6260
6261 if ($return = $DB->get_records_sql($sql, $params)) {
6262 return $return;
6263 }
6264
6265 return array();
6266 }
6267
6268 /**
6269 * Returns the count of records for the provided user and forum and [optionally] group.
6270 *
6271 * @global object
6272 * @global object
6273 * @global object
6274 * @param object $cm
6275 * @param object $course
6276 * @return int
6277 */
6278 function forum_tp_count_forum_unread_posts($cm, $course) {
6279 global $CFG, $USER, $DB;
6280
6281 static $readcache = array();
6282
6283 $forumid = $cm->instance;
6284
6285 if (!isset($readcache[$course->id])) {
6286 $readcache[$course->id] = array();
6287 if ($counts = forum_tp_get_course_unread_posts($USER->id, $course->id)) {
6288 foreach ($counts as $count) {
6289 $readcache[$course->id][$count->id] = $count->unread;
6290 }
6291 }
6292 }
6293
6294 if (empty($readcache[$course->id][$forumid])) {
6295 // no need to check group mode ;-)
6296 return 0;
6297 }
6298
6299 $groupmode = groups_get_activity_groupmode($cm, $course);
6300
6301 if ($groupmode != SEPARATEGROUPS) {
6302 return $readcache[$course->id][$forumid];
6303 }
6304
6305 if (has_capability('moodle/site:accessallgroups', context_module::instance($cm->id))) {
6306 return $readcache[$course->id][$forumid];
6307 }
6308
6309 require_once($CFG->dirroot.'/course/lib.php');
6310
6311 $modinfo = get_fast_modinfo($course);
6312
6313 $mygroups = $modinfo->get_groups($cm->groupingid);
6314
6315 // add all groups posts
6316 $mygroups[-1] = -1;
6317
6318 list ($groups_sql, $groups_params) = $DB->get_in_or_equal($mygroups);
6319
6320 $now = round(time(), -2); // db cache friendliness
6321 $cutoffdate = $now - ($CFG->forum_oldpostdays*24*60*60);
6322 $params = array($USER->id, $forumid, $cutoffdate);
6323
6324 if (!empty($CFG->forum_enabletimedposts)) {
6325 $timedsql = "AND d.timestart < ? AND (d.timeend = 0 OR d.timeend > ?)";
6326 $params[] = $now;
6327 $params[] = $now;
6328 } else {
6329 $timedsql = "";
6330 }
6331
6332 $params = array_merge($params, $groups_params);
6333
6334 $sql = "SELECT COUNT(p.id)
6335 FROM {forum_posts} p
6336 JOIN {forum_discussions} d ON p.discussion = d.id
6337 LEFT JOIN {forum_read} r ON (r.postid = p.id AND r.userid = ?)
6338 WHERE d.forum = ?
6339 AND p.modified >= ? AND r.id is NULL
6340 $timedsql
6341 AND d.groupid $groups_sql";
6342
6343 return $DB->get_field_sql($sql, $params);
6344 }
6345
6346 /**
6347 * Deletes read records for the specified index. At least one parameter must be specified.
6348 *
6349 * @global object
6350 * @param int $userid
6351 * @param int $postid
6352 * @param int $discussionid
6353 * @param int $forumid
6354 * @return bool
6355 */
6356 function forum_tp_delete_read_records($userid=-1, $postid=-1, $discussionid=-1, $forumid=-1) {
6357 global $DB;
6358 $params = array();
6359
6360 $select = '';
6361 if ($userid > -1) {
6362 if ($select != '') $select .= ' AND ';
6363 $select .= 'userid = ?';
6364 $params[] = $userid;
6365 }
6366 if ($postid > -1) {
6367 if ($select != '') $select .= ' AND ';
6368 $select .= 'postid = ?';
6369 $params[] = $postid;
6370 }
6371 if ($discussionid > -1) {
6372 if ($select != '') $select .= ' AND ';
6373 $select .= 'discussionid = ?';
6374 $params[] = $discussionid;
6375 }
6376 if ($forumid > -1) {
6377 if ($select != '') $select .= ' AND ';
6378 $select .= 'forumid = ?';
6379 $params[] = $forumid;
6380 }
6381 if ($select == '') {
6382 return false;
6383 }
6384 else {
6385 return $DB->delete_records_select('forum_read', $select, $params);
6386 }
6387 }
6388 /**
6389 * Get a list of forums not tracked by the user.
6390 *
6391 * @global object
6392 * @global object
6393 * @param int $userid The id of the user to use.
6394 * @param int $courseid The id of the course being checked.
6395 * @return mixed An array indexed by forum id, or false.
6396 */
6397 function forum_tp_get_untracked_forums($userid, $courseid) {
6398 global $CFG, $DB;
6399
6400 if ($CFG->forum_allowforcedreadtracking) {
6401 $trackingsql = "AND (f.trackingtype = ".FORUM_TRACKING_OFF."
6402 OR (f.trackingtype = ".FORUM_TRACKING_OPTIONAL." AND (ft.id IS NOT NULL
6403 OR (SELECT trackforums FROM {user} WHERE id = ?) = 0)))";
6404 } else {
6405 $trackingsql = "AND (f.trackingtype = ".FORUM_TRACKING_OFF."
6406 OR ((f.trackingtype = ".FORUM_TRACKING_OPTIONAL." OR f.trackingtype = ".FORUM_TRACKING_FORCED.")
6407 AND (ft.id IS NOT NULL
6408 OR (SELECT trackforums FROM {user} WHERE id = ?) = 0)))";
6409 }
6410
6411 $sql = "SELECT f.id
6412 FROM {forum} f
6413 LEFT JOIN {forum_track_prefs} ft ON (ft.forumid = f.id AND ft.userid = ?)
6414 WHERE f.course = ?
6415 $trackingsql";
6416
6417 if ($forums = $DB->get_records_sql($sql, array($userid, $courseid, $userid))) {
6418 foreach ($forums as $forum) {
6419 $forums[$forum->id] = $forum;
6420 }
6421 return $forums;
6422
6423 } else {
6424 return array();
6425 }
6426 }
6427
6428 /**
6429 * Determine if a user can track forums and optionally a particular forum.
6430 * Checks the site settings, the user settings and the forum settings (if
6431 * requested).
6432 *
6433 * @global object
6434 * @global object
6435 * @global object
6436 * @param mixed $forum The forum object to test, or the int id (optional).
6437 * @param mixed $userid The user object to check for (optional).
6438 * @return boolean
6439 */
6440 function forum_tp_can_track_forums($forum=false, $user=false) {
6441 global $USER, $CFG, $DB;
6442
6443 // if possible, avoid expensive
6444 // queries
6445 if (empty($CFG->forum_trackreadposts)) {
6446 return false;
6447 }
6448
6449 if ($user === false) {
6450 $user = $USER;
6451 }
6452
6453 if (isguestuser($user) or empty($user->id)) {
6454 return false;
6455 }
6456
6457 if ($forum === false) {
6458 if ($CFG->forum_allowforcedreadtracking) {
6459 // Since we can force tracking, assume yes without a specific forum.
6460 return true;
6461 } else {
6462 return (bool)$user->trackforums;
6463 }
6464 }
6465
6466 // Work toward always passing an object...
6467 if (is_numeric($forum)) {
6468 debugging('Better use proper forum object.', DEBUG_DEVELOPER);
6469 $forum = $DB->get_record('forum', array('id' => $forum), '', 'id,trackingtype');
6470 }
6471
6472 $forumallows = ($forum->trackingtype == FORUM_TRACKING_OPTIONAL);
6473 $forumforced = ($forum->trackingtype == FORUM_TRACKING_FORCED);
6474
6475 if ($CFG->forum_allowforcedreadtracking) {
6476 // If we allow forcing, then forced forums takes procidence over user setting.
6477 return ($forumforced || ($forumallows && (!empty($user->trackforums) && (bool)$user->trackforums)));
6478 } else {
6479 // If we don't allow forcing, user setting trumps.
6480 return ($forumforced || $forumallows) && !empty($user->trackforums);
6481 }
6482 }
6483
6484 /**
6485 * Tells whether a specific forum is tracked by the user. A user can optionally
6486 * be specified. If not specified, the current user is assumed.
6487 *
6488 * @global object
6489 * @global object
6490 * @global object
6491 * @param mixed $forum If int, the id of the forum being checked; if object, the forum object
6492 * @param int $userid The id of the user being checked (optional).
6493 * @return boolean
6494 */
6495 function forum_tp_is_tracked($forum, $user=false) {
6496 global $USER, $CFG, $DB;
6497
6498 if ($user === false) {
6499 $user = $USER;
6500 }
6501
6502 if (isguestuser($user) or empty($user->id)) {
6503 return false;
6504 }
6505
6506 // Work toward always passing an object...
6507 if (is_numeric($forum)) {
6508 debugging('Better use proper forum object.', DEBUG_DEVELOPER);
6509 $forum = $DB->get_record('forum', array('id' => $forum));
6510 }
6511
6512 if (!forum_tp_can_track_forums($forum, $user)) {
6513 return false;
6514 }
6515
6516 $forumallows = ($forum->trackingtype == FORUM_TRACKING_OPTIONAL);
6517 $forumforced = ($forum->trackingtype == FORUM_TRACKING_FORCED);
6518 $userpref = $DB->get_record('forum_track_prefs', array('userid' => $user->id, 'forumid' => $forum->id));
6519
6520 if ($CFG->forum_allowforcedreadtracking) {
6521 return $forumforced || ($forumallows && $userpref === false);
6522 } else {
6523 return ($forumallows || $forumforced) && $userpref === false;
6524 }
6525 }
6526
6527 /**
6528 * @global object
6529 * @global object
6530 * @param int $forumid
6531 * @param int $userid
6532 */
6533 function forum_tp_start_tracking($forumid, $userid=false) {
6534 global $USER, $DB;
6535
6536 if ($userid === false) {
6537 $userid = $USER->id;
6538 }
6539
6540 return $DB->delete_records('forum_track_prefs', array('userid' => $userid, 'forumid' => $forumid));
6541 }
6542
6543 /**
6544 * @global object
6545 * @global object
6546 * @param int $forumid
6547 * @param int $userid
6548 */
6549 function forum_tp_stop_tracking($forumid, $userid=false) {
6550 global $USER, $DB;
6551
6552 if ($userid === false) {
6553 $userid = $USER->id;
6554 }
6555
6556 if (!$DB->record_exists('forum_track_prefs', array('userid' => $userid, 'forumid' => $forumid))) {
6557 $track_prefs = new stdClass();
6558 $track_prefs->userid = $userid;
6559 $track_prefs->forumid = $forumid;
6560 $DB->insert_record('forum_track_prefs', $track_prefs);
6561 }
6562
6563 return forum_tp_delete_read_records($userid, -1, -1, $forumid);
6564 }
6565
6566
6567 /**
6568 * Clean old records from the forum_read table.
6569 * @global object
6570 * @global object
6571 * @return void
6572 */
6573 function forum_tp_clean_read_records() {
6574 global $CFG, $DB;
6575
6576 if (!isset($CFG->forum_oldpostdays)) {
6577 return;
6578 }
6579 // Look for records older than the cutoffdate that are still in the forum_read table.
6580 $cutoffdate = time() - ($CFG->forum_oldpostdays*24*60*60);
6581
6582 //first get the oldest tracking present - we need tis to speedup the next delete query
6583 $sql = "SELECT MIN(fp.modified) AS first
6584 FROM {forum_posts} fp
6585 JOIN {forum_read} fr ON fr.postid=fp.id";
6586 if (!$first = $DB->get_field_sql($sql)) {
6587 // nothing to delete;
6588 return;
6589 }
6590
6591 // now delete old tracking info
6592 $sql = "DELETE
6593 FROM {forum_read}
6594 WHERE postid IN (SELECT fp.id
6595 FROM {forum_posts} fp
6596 WHERE fp.modified >= ? AND fp.modified < ?)";
6597 $DB->execute($sql, array($first, $cutoffdate));
6598 }
6599
6600 /**
6601 * Sets the last post for a given discussion
6602 *
6603 * @global object
6604 * @global object
6605 * @param into $discussionid
6606 * @return bool|int
6607 **/
6608 function forum_discussion_update_last_post($discussionid) {
6609 global $CFG, $DB;
6610
6611 // Check the given discussion exists
6612 if (!$DB->record_exists('forum_discussions', array('id' => $discussionid))) {
6613 return false;
6614 }
6615
6616 // Use SQL to find the last post for this discussion
6617 $sql = "SELECT id, userid, modified
6618 FROM {forum_posts}
6619 WHERE discussion=?
6620 ORDER BY modified DESC";
6621
6622 // Lets go find the last post
6623 if (($lastposts = $DB->get_records_sql($sql, array($discussionid), 0, 1))) {
6624 $lastpost = reset($lastposts);
6625 $discussionobject = new stdClass();
6626 $discussionobject->id = $discussionid;
6627 $discussionobject->usermodified = $lastpost->userid;
6628 $discussionobject->timemodified = $lastpost->modified;
6629 $DB->update_record('forum_discussions', $discussionobject);
6630 return $lastpost->id;
6631 }
6632
6633 // To get here either we couldn't find a post for the discussion (weird)
6634 // or we couldn't update the discussion record (weird x2)
6635 return false;
6636 }
6637
6638
6639 /**
6640 * List the actions that correspond to a view of this module.
6641 * This is used by the participation report.
6642 *
6643 * Note: This is not used by new logging system. Event with
6644 * crud = 'r' and edulevel = LEVEL_PARTICIPATING will
6645 * be considered as view action.
6646 *
6647 * @return array
6648 */
6649 function forum_get_view_actions() {
6650 return array('view discussion', 'search', 'forum', 'forums', 'subscribers', 'view forum');
6651 }
6652
6653 /**
6654 * List the actions that correspond to a post of this module.
6655 * This is used by the participation report.
6656 *
6657 * Note: This is not used by new logging system. Event with
6658 * crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
6659 * will be considered as post action.
6660 *
6661 * @return array
6662 */
6663 function forum_get_post_actions() {
6664 return array('add discussion','add post','delete discussion','delete post','move discussion','prune post','update post');
6665 }
6666
6667 /**
6668 * Returns a warning object if a user has reached the number of posts equal to
6669 * the warning/blocking setting, or false if there is no warning to show.
6670 *
6671 * @param int|stdClass $forum the forum id or the forum object
6672 * @param stdClass $cm the course module
6673 * @return stdClass|bool returns an object with the warning information, else
6674 * returns false if no warning is required.
6675 */
6676 function forum_check_throttling($forum, $cm = null) {
6677 global $CFG, $DB, $USER;
6678
6679 if (is_numeric($forum)) {
6680 $forum = $DB->get_record('forum', array('id' => $forum), '*', MUST_EXIST);
6681 }
6682
6683 if (!is_object($forum)) {
6684 return false; // This is broken.
6685 }
6686
6687 if (!$cm) {
6688 $cm = get_coursemodule_from_instance('forum', $forum->id, $forum->course, false, MUST_EXIST);
6689 }
6690
6691 if (empty($forum->blockafter)) {
6692 return false;
6693 }
6694
6695 if (empty($forum->blockperiod)) {
6696 return false;
6697 }
6698
6699 $modcontext = context_module::instance($cm->id);
6700 if (has_capability('mod/forum:postwithoutthrottling', $modcontext)) {
6701 return false;
6702 }
6703
6704 // Get the number of posts in the last period we care about.
6705 $timenow = time();
6706 $timeafter = $timenow - $forum->blockperiod;
6707 $numposts = $DB->count_records_sql('SELECT COUNT(p.id) FROM {forum_posts} p
6708 JOIN {forum_discussions} d
6709 ON p.discussion = d.id WHERE d.forum = ?
6710 AND p.userid = ? AND p.created > ?', array($forum->id, $USER->id, $timeafter));
6711
6712 $a = new stdClass();
6713 $a->blockafter = $forum->blockafter;
6714 $a->numposts = $numposts;
6715 $a->blockperiod = get_string('secondstotime'.$forum->blockperiod);
6716
6717 if ($forum->blockafter <= $numposts) {
6718 $warning = new stdClass();
6719 $warning->canpost = false;
6720 $warning->errorcode = 'forumblockingtoomanyposts';
6721 $warning->module = 'error';
6722 $warning->additional = $a;
6723 $warning->link = $CFG->wwwroot . '/mod/forum/view.php?f=' . $forum->id;
6724
6725 return $warning;
6726 }
6727
6728 if ($forum->warnafter <= $numposts) {
6729 $warning = new stdClass();
6730 $warning->canpost = true;
6731 $warning->errorcode = 'forumblockingalmosttoomanyposts';
6732 $warning->module = 'forum';
6733 $warning->additional = $a;
6734 $warning->link = null;
6735
6736 return $warning;
6737 }
6738 }
6739
6740 /**
6741 * Throws an error if the user is no longer allowed to post due to having reached
6742 * or exceeded the number of posts specified in 'Post threshold for blocking'
6743 * setting.
6744 *
6745 * @since Moodle 2.5
6746 * @param stdClass $thresholdwarning the warning information returned
6747 * from the function forum_check_throttling.
6748 */
6749 function forum_check_blocking_threshold($thresholdwarning) {
6750 if (!empty($thresholdwarning) && !$thresholdwarning->canpost) {
6751 print_error($thresholdwarning->errorcode,
6752 $thresholdwarning->module,
6753 $thresholdwarning->link,
6754 $thresholdwarning->additional);
6755 }
6756 }
6757
6758
6759 /**
6760 * Removes all grades from gradebook
6761 *
6762 * @global object
6763 * @global object
6764 * @param int $courseid
6765 * @param string $type optional
6766 */
6767 function forum_reset_gradebook($courseid, $type='') {
6768 global $CFG, $DB;
6769
6770 $wheresql = '';
6771 $params = array($courseid);
6772 if ($type) {
6773 $wheresql = "AND f.type=?";
6774 $params[] = $type;
6775 }
6776
6777 $sql = "SELECT f.*, cm.idnumber as cmidnumber, f.course as courseid
6778 FROM {forum} f, {course_modules} cm, {modules} m
6779 WHERE m.name='forum' AND m.id=cm.module AND cm.instance=f.id AND f.course=? $wheresql";
6780
6781 if ($forums = $DB->get_records_sql($sql, $params)) {
6782 foreach ($forums as $forum) {
6783 forum_grade_item_update($forum, 'reset');
6784 }
6785 }
6786 }
6787
6788 /**
6789 * This function is used by the reset_course_userdata function in moodlelib.
6790 * This function will remove all posts from the specified forum
6791 * and clean up any related data.
6792 *
6793 * @global object
6794 * @global object
6795 * @param $data the data submitted from the reset course.
6796 * @return array status array
6797 */
6798 function forum_reset_userdata($data) {
6799 global $CFG, $DB;
6800 require_once($CFG->dirroot.'/rating/lib.php');
6801
6802 $componentstr = get_string('modulenameplural', 'forum');
6803 $status = array();
6804
6805 $params = array($data->courseid);
6806
6807 $removeposts = false;
6808 $typesql = "";
6809 if (!empty($data->reset_forum_all)) {
6810 $removeposts = true;
6811 $typesstr = get_string('resetforumsall', 'forum');
6812 $types = array();
6813 } else if (!empty($data->reset_forum_types)){
6814 $removeposts = true;
6815 $typesql = "";
6816 $types = array();
6817 $forum_types_all = forum_get_forum_types_all();
6818 foreach ($data->reset_forum_types as $type) {
6819 if (!array_key_exists($type, $forum_types_all)) {
6820 continue;
6821 }
6822 $typesql .= " AND f.type=?";
6823 $types[] = $forum_types_all[$type];
6824 $params[] = $type;
6825 }
6826 $typesstr = get_string('resetforums', 'forum').': '.implode(', ', $types);
6827 }
6828 $alldiscussionssql = "SELECT fd.id
6829 FROM {forum_discussions} fd, {forum} f
6830 WHERE f.course=? AND f.id=fd.forum";
6831
6832 $allforumssql = "SELECT f.id
6833 FROM {forum} f
6834 WHERE f.course=?";
6835
6836 $allpostssql = "SELECT fp.id
6837 FROM {forum_posts} fp, {forum_discussions} fd, {forum} f
6838 WHERE f.course=? AND f.id=fd.forum AND fd.id=fp.discussion";
6839
6840 $forumssql = $forums = $rm = null;
6841
6842 if( $removeposts || !empty($data->reset_forum_ratings) ) {
6843 $forumssql = "$allforumssql $typesql";
6844 $forums = $forums = $DB->get_records_sql($forumssql, $params);
6845 $rm = new rating_manager();
6846 $ratingdeloptions = new stdClass;
6847 $ratingdeloptions->component = 'mod_forum';
6848 $ratingdeloptions->ratingarea = 'post';
6849 }
6850
6851 if ($removeposts) {
6852 $discussionssql = "$alldiscussionssql $typesql";
6853 $postssql = "$allpostssql $typesql";
6854
6855 // now get rid of all attachments
6856 $fs = get_file_storage();
6857 if ($forums) {
6858 foreach ($forums as $forumid=>$unused) {
6859 if (!$cm = get_coursemodule_from_instance('forum', $forumid)) {
6860 continue;
6861 }
6862 $context = context_module::instance($cm->id);
6863 $fs->delete_area_files($context->id, 'mod_forum', 'attachment');
6864 $fs->delete_area_files($context->id, 'mod_forum', 'post');
6865
6866 //remove ratings
6867 $ratingdeloptions->contextid = $context->id;
6868 $rm->delete_ratings($ratingdeloptions);
6869 }
6870 }
6871
6872 // first delete all read flags
6873 $DB->delete_records_select('forum_read', "forumid IN ($forumssql)", $params);
6874
6875 // remove tracking prefs
6876 $DB->delete_records_select('forum_track_prefs', "forumid IN ($forumssql)", $params);
6877
6878 // remove posts from queue
6879 $DB->delete_records_select('forum_queue', "discussionid IN ($discussionssql)", $params);
6880
6881 // all posts - initial posts must be kept in single simple discussion forums
6882 $DB->delete_records_select('forum_posts', "discussion IN ($discussionssql) AND parent <> 0", $params); // first all children
6883 $DB->delete_records_select('forum_posts', "discussion IN ($discussionssql AND f.type <> 'single') AND parent = 0", $params); // now the initial posts for non single simple
6884
6885 // finally all discussions except single simple forums
6886 $DB->delete_records_select('forum_discussions', "forum IN ($forumssql AND f.type <> 'single')", $params);
6887
6888 // remove all grades from gradebook
6889 if (empty($data->reset_gradebook_grades)) {
6890 if (empty($types)) {
6891 forum_reset_gradebook($data->courseid);
6892 } else {
6893 foreach ($types as $type) {
6894 forum_reset_gradebook($data->courseid, $type);
6895 }
6896 }
6897 }
6898
6899 $status[] = array('component'=>$componentstr, 'item'=>$typesstr, 'error'=>false);
6900 }
6901
6902 // remove all ratings in this course's forums
6903 if (!empty($data->reset_forum_ratings)) {
6904 if ($forums) {
6905 foreach ($forums as $forumid=>$unused) {
6906 if (!$cm = get_coursemodule_from_instance('forum', $forumid)) {
6907 continue;
6908 }
6909 $context = context_module::instance($cm->id);
6910
6911 //remove ratings
6912 $ratingdeloptions->contextid = $context->id;
6913 $rm->delete_ratings($ratingdeloptions);
6914 }
6915 }
6916
6917 // remove all grades from gradebook
6918 if (empty($data->reset_gradebook_grades)) {
6919 forum_reset_gradebook($data->courseid);
6920 }
6921 }
6922
6923 // remove all digest settings unconditionally - even for users still enrolled in course.
6924 if (!empty($data->reset_forum_digests)) {
6925 $DB->delete_records_select('forum_digests', "forum IN ($allforumssql)", $params);
6926 $status[] = array('component' => $componentstr, 'item' => get_string('resetdigests', 'forum'), 'error' => false);
6927 }
6928
6929 // remove all subscriptions unconditionally - even for users still enrolled in course
6930 if (!empty($data->reset_forum_subscriptions)) {
6931 $DB->delete_records_select('forum_subscriptions', "forum IN ($allforumssql)", $params);
6932 $DB->delete_records_select('forum_discussion_subs', "forum IN ($allforumssql)", $params);
6933 $status[] = array('component' => $componentstr, 'item' => get_string('resetsubscriptions', 'forum'), 'error' => false);
6934 }
6935
6936 // remove all tracking prefs unconditionally - even for users still enrolled in course
6937 if (!empty($data->reset_forum_track_prefs)) {
6938 $DB->delete_records_select('forum_track_prefs', "forumid IN ($allforumssql)", $params);
6939 $status[] = array('component'=>$componentstr, 'item'=>get_string('resettrackprefs','forum'), 'error'=>false);
6940 }
6941
6942 /// updating dates - shift may be negative too
6943 if ($data->timeshift) {
6944 shift_course_mod_dates('forum', array('assesstimestart', 'assesstimefinish'), $data->timeshift, $data->courseid);
6945 $status[] = array('component'=>$componentstr, 'item'=>get_string('datechanged'), 'error'=>false);
6946 }
6947
6948 return $status;
6949 }
6950
6951 /**
6952 * Called by course/reset.php
6953 *
6954 * @param $mform form passed by reference
6955 */
6956 function forum_reset_course_form_definition(&$mform) {
6957 $mform->addElement('header', 'forumheader', get_string('modulenameplural', 'forum'));
6958
6959 $mform->addElement('checkbox', 'reset_forum_all', get_string('resetforumsall','forum'));
6960
6961 $mform->addElement('select', 'reset_forum_types', get_string('resetforums', 'forum'), forum_get_forum_types_all(), array('multiple' => 'multiple'));
6962 $mform->setAdvanced('reset_forum_types');
6963 $mform->disabledIf('reset_forum_types', 'reset_forum_all', 'checked');
6964
6965 $mform->addElement('checkbox', 'reset_forum_digests', get_string('resetdigests','forum'));
6966 $mform->setAdvanced('reset_forum_digests');
6967
6968 $mform->addElement('checkbox', 'reset_forum_subscriptions', get_string('resetsubscriptions','forum'));
6969 $mform->setAdvanced('reset_forum_subscriptions');
6970
6971 $mform->addElement('checkbox', 'reset_forum_track_prefs', get_string('resettrackprefs','forum'));
6972 $mform->setAdvanced('reset_forum_track_prefs');
6973 $mform->disabledIf('reset_forum_track_prefs', 'reset_forum_all', 'checked');
6974
6975 $mform->addElement('checkbox', 'reset_forum_ratings', get_string('deleteallratings'));
6976 $mform->disabledIf('reset_forum_ratings', 'reset_forum_all', 'checked');
6977 }
6978
6979 /**
6980 * Course reset form defaults.
6981 * @return array
6982 */
6983 function forum_reset_course_form_defaults($course) {
6984 return array('reset_forum_all'=>1, 'reset_forum_digests' => 0, 'reset_forum_subscriptions'=>0, 'reset_forum_track_prefs'=>0, 'reset_forum_ratings'=>1);
6985 }
6986
6987 /**
6988 * Returns array of forum layout modes
6989 *
6990 * @return array
6991 */
6992 function forum_get_layout_modes() {
6993 return array (FORUM_MODE_FLATOLDEST => get_string('modeflatoldestfirst', 'forum'),
6994 FORUM_MODE_FLATNEWEST => get_string('modeflatnewestfirst', 'forum'),
6995 FORUM_MODE_THREADED => get_string('modethreaded', 'forum'),
6996 FORUM_MODE_NESTED => get_string('modenested', 'forum'));
6997 }
6998
6999 /**
7000 * Returns array of forum types chooseable on the forum editing form
7001 *
7002 * @return array
7003 */
7004 function forum_get_forum_types() {
7005 return array ('general' => get_string('generalforum', 'forum'),
7006 'eachuser' => get_string('eachuserforum', 'forum'),
7007 'single' => get_string('singleforum', 'forum'),
7008 'qanda' => get_string('qandaforum', 'forum'),
7009 'blog' => get_string('blogforum', 'forum'));
7010 }
7011
7012 /**
7013 * Returns array of all forum layout modes
7014 *
7015 * @return array
7016 */
7017 function forum_get_forum_types_all() {
7018 return array ('news' => get_string('namenews','forum'),
7019 'social' => get_string('namesocial','forum'),
7020 'general' => get_string('generalforum', 'forum'),
7021 'eachuser' => get_string('eachuserforum', 'forum'),
7022 'single' => get_string('singleforum', 'forum'),
7023 'qanda' => get_string('qandaforum', 'forum'),
7024 'blog' => get_string('blogforum', 'forum'));
7025 }
7026
7027 /**
7028 * Returns all other caps used in module
7029 *
7030 * @return array
7031 */
7032 function forum_get_extra_capabilities() {
7033 return array('moodle/site:accessallgroups', 'moodle/site:viewfullnames', 'moodle/site:trustcontent', 'moodle/rating:view', 'moodle/rating:viewany', 'moodle/rating:viewall', 'moodle/rating:rate');
7034 }
7035
7036 /**
7037 * Adds module specific settings to the settings block
7038 *
7039 * @param settings_navigation $settings The settings navigation object
7040 * @param navigation_node $forumnode The node to add module settings to
7041 */
7042 function forum_extend_settings_navigation(settings_navigation $settingsnav, navigation_node $forumnode) {
7043 global $USER, $PAGE, $CFG, $DB, $OUTPUT;
7044
7045 $forumobject = $DB->get_record("forum", array("id" => $PAGE->cm->instance));
7046 if (empty($PAGE->cm->context)) {
7047 $PAGE->cm->context = context_module::instance($PAGE->cm->instance);
7048 }
7049
7050 $params = $PAGE->url->params();
7051 if (!empty($params['d'])) {
7052 $discussionid = $params['d'];
7053 }
7054
7055 // for some actions you need to be enrolled, beiing admin is not enough sometimes here
7056 $enrolled = is_enrolled($PAGE->cm->context, $USER, '', false);
7057 $activeenrolled = is_enrolled($PAGE->cm->context, $USER, '', true);
7058
7059 $canmanage = has_capability('mod/forum:managesubscriptions', $PAGE->cm->context);
7060 $subscriptionmode = \mod_forum\subscriptions::get_subscription_mode($forumobject);
7061 $cansubscribe = $activeenrolled && !\mod_forum\subscriptions::is_forcesubscribed($forumobject) &&
7062 (!\mod_forum\subscriptions::subscription_disabled($forumobject) || $canmanage);
7063
7064 if ($canmanage) {
7065 $mode = $forumnode->add(get_string('subscriptionmode', 'forum'), null, navigation_node::TYPE_CONTAINER);
7066
7067 $allowchoice = $mode->add(get_string('subscriptionoptional', 'forum'), new moodle_url('/mod/forum/subscribe.php', array('id'=>$forumobject->id, 'mode'=>FORUM_CHOOSESUBSCRIBE, 'sesskey'=>sesskey())), navigation_node::TYPE_SETTING);
7068 $forceforever = $mode->add(get_string("subscriptionforced", "forum"), new moodle_url('/mod/forum/subscribe.php', array('id'=>$forumobject->id, 'mode'=>FORUM_FORCESUBSCRIBE, 'sesskey'=>sesskey())), navigation_node::TYPE_SETTING);
7069 $forceinitially = $mode->add(get_string("subscriptionauto", "forum"), new moodle_url('/mod/forum/subscribe.php', array('id'=>$forumobject->id, 'mode'=>FORUM_INITIALSUBSCRIBE, 'sesskey'=>sesskey())), navigation_node::TYPE_SETTING);
7070 $disallowchoice = $mode->add(get_string('subscriptiondisabled', 'forum'), new moodle_url('/mod/forum/subscribe.php', array('id'=>$forumobject->id, 'mode'=>FORUM_DISALLOWSUBSCRIBE, 'sesskey'=>sesskey())), navigation_node::TYPE_SETTING);
7071
7072 switch ($subscriptionmode) {
7073 case FORUM_CHOOSESUBSCRIBE : // 0
7074 $allowchoice->action = null;
7075 $allowchoice->add_class('activesetting');
7076 break;
7077 case FORUM_FORCESUBSCRIBE : // 1
7078 $forceforever->action = null;
7079 $forceforever->add_class('activesetting');
7080 break;
7081 case FORUM_INITIALSUBSCRIBE : // 2
7082 $forceinitially->action = null;
7083 $forceinitially->add_class('activesetting');
7084 break;
7085 case FORUM_DISALLOWSUBSCRIBE : // 3
7086 $disallowchoice->action = null;
7087 $disallowchoice->add_class('activesetting');
7088 break;
7089 }
7090
7091 } else if ($activeenrolled) {
7092
7093 switch ($subscriptionmode) {
7094 case FORUM_CHOOSESUBSCRIBE : // 0
7095 $notenode = $forumnode->add(get_string('subscriptionoptional', 'forum'));
7096 break;
7097 case FORUM_FORCESUBSCRIBE : // 1
7098 $notenode = $forumnode->add(get_string('subscriptionforced', 'forum'));
7099 break;
7100 case FORUM_INITIALSUBSCRIBE : // 2
7101 $notenode = $forumnode->add(get_string('subscriptionauto', 'forum'));
7102 break;
7103 case FORUM_DISALLOWSUBSCRIBE : // 3
7104 $notenode = $forumnode->add(get_string('subscriptiondisabled', 'forum'));
7105 break;
7106 }
7107 }
7108
7109 if ($cansubscribe) {
7110 if (\mod_forum\subscriptions::is_subscribed($USER->id, $forumobject, null, $PAGE->cm)) {
7111 $linktext = get_string('unsubscribe', 'forum');
7112 } else {
7113 $linktext = get_string('subscribe', 'forum');
7114 }
7115 $url = new moodle_url('/mod/forum/subscribe.php', array('id'=>$forumobject->id, 'sesskey'=>sesskey()));
7116 $forumnode->add($linktext, $url, navigation_node::TYPE_SETTING);
7117
7118 if (isset($discussionid)) {
7119 if (\mod_forum\subscriptions::is_subscribed($USER->id, $forumobject, $discussionid, $PAGE->cm)) {
7120 $linktext = get_string('unsubscribediscussion', 'forum');
7121 } else {
7122 $linktext = get_string('subscribediscussion', 'forum');
7123 }
7124 $url = new moodle_url('/mod/forum/subscribe.php', array(
7125 'id' => $forumobject->id,
7126 'sesskey' => sesskey(),
7127 'd' => $discussionid,
7128 'returnurl' => $PAGE->url->out(),
7129 ));
7130 $forumnode->add($linktext, $url, navigation_node::TYPE_SETTING);
7131 }
7132 }
7133
7134 if (has_capability('mod/forum:viewsubscribers', $PAGE->cm->context)){
7135 $url = new moodle_url('/mod/forum/subscribers.php', array('id'=>$forumobject->id));
7136 $forumnode->add(get_string('showsubscribers', 'forum'), $url, navigation_node::TYPE_SETTING);
7137 }
7138
7139 if ($enrolled && forum_tp_can_track_forums($forumobject)) { // keep tracking info for users with suspended enrolments
7140 if ($forumobject->trackingtype == FORUM_TRACKING_OPTIONAL
7141 || ((!$CFG->forum_allowforcedreadtracking) && $forumobject->trackingtype == FORUM_TRACKING_FORCED)) {
7142 if (forum_tp_is_tracked($forumobject)) {
7143 $linktext = get_string('notrackforum', 'forum');
7144 } else {
7145 $linktext = get_string('trackforum', 'forum');
7146 }
7147 $url = new moodle_url('/mod/forum/settracking.php', array(
7148 'id' => $forumobject->id,
7149 'sesskey' => sesskey(),
7150 ));
7151 $forumnode->add($linktext, $url, navigation_node::TYPE_SETTING);
7152 }
7153 }
7154
7155 if (!isloggedin() && $PAGE->course->id == SITEID) {
7156 $userid = guest_user()->id;
7157 } else {
7158 $userid = $USER->id;
7159 }
7160
7161 $hascourseaccess = ($PAGE->course->id == SITEID) || can_access_course($PAGE->course, $userid);
7162 $enablerssfeeds = !empty($CFG->enablerssfeeds) && !empty($CFG->forum_enablerssfeeds);
7163
7164 if ($enablerssfeeds && $forumobject->rsstype && $forumobject->rssarticles && $hascourseaccess) {
7165
7166 if (!function_exists('rss_get_url')) {
7167 require_once("$CFG->libdir/rsslib.php");
7168 }
7169
7170 if ($forumobject->rsstype == 1) {
7171 $string = get_string('rsssubscriberssdiscussions','forum');
7172 } else {
7173 $string = get_string('rsssubscriberssposts','forum');
7174 }
7175
7176 $url = new moodle_url(rss_get_url($PAGE->cm->context->id, $userid, "mod_forum", $forumobject->id));
7177 $forumnode->add($string, $url, settings_navigation::TYPE_SETTING, null, null, new pix_icon('i/rss', ''));
7178 }
7179 }
7180
7181 /**
7182 * Adds information about unread messages, that is only required for the course view page (and
7183 * similar), to the course-module object.
7184 * @param cm_info $cm Course-module object
7185 */
7186 function forum_cm_info_view(cm_info $cm) {
7187 global $CFG;
7188
7189 if (forum_tp_can_track_forums()) {
7190 if ($unread = forum_tp_count_forum_unread_posts($cm, $cm->get_course())) {
7191 $out = '<span class="unread"> <a href="' . $cm->url . '">';
7192 if ($unread == 1) {
7193 $out .= get_string('unreadpostsone', 'forum');
7194 } else {
7195 $out .= get_string('unreadpostsnumber', 'forum', $unread);
7196 }
7197 $out .= '</a></span>';
7198 $cm->set_after_link($out);
7199 }
7200 }
7201 }
7202
7203 /**
7204 * Return a list of page types
7205 * @param string $pagetype current page type
7206 * @param stdClass $parentcontext Block's parent context
7207 * @param stdClass $currentcontext Current context of block
7208 */
7209 function forum_page_type_list($pagetype, $parentcontext, $currentcontext) {
7210 $forum_pagetype = array(
7211 'mod-forum-*'=>get_string('page-mod-forum-x', 'forum'),
7212 'mod-forum-view'=>get_string('page-mod-forum-view', 'forum'),
7213 'mod-forum-discuss'=>get_string('page-mod-forum-discuss', 'forum')
7214 );
7215 return $forum_pagetype;
7216 }
7217
7218 /**
7219 * Gets all of the courses where the provided user has posted in a forum.
7220 *
7221 * @global moodle_database $DB The database connection
7222 * @param stdClass $user The user who's posts we are looking for
7223 * @param bool $discussionsonly If true only look for discussions started by the user
7224 * @param bool $includecontexts If set to trye contexts for the courses will be preloaded
7225 * @param int $limitfrom The offset of records to return
7226 * @param int $limitnum The number of records to return
7227 * @return array An array of courses
7228 */
7229 function forum_get_courses_user_posted_in($user, $discussionsonly = false, $includecontexts = true, $limitfrom = null, $limitnum = null) {
7230 global $DB;
7231
7232 // If we are only after discussions we need only look at the forum_discussions
7233 // table and join to the userid there. If we are looking for posts then we need
7234 // to join to the forum_posts table.
7235 if (!$discussionsonly) {
7236 $subquery = "(SELECT DISTINCT fd.course
7237 FROM {forum_discussions} fd
7238 JOIN {forum_posts} fp ON fp.discussion = fd.id
7239 WHERE fp.userid = :userid )";
7240 } else {
7241 $subquery= "(SELECT DISTINCT fd.course
7242 FROM {forum_discussions} fd
7243 WHERE fd.userid = :userid )";
7244 }
7245
7246 $params = array('userid' => $user->id);
7247
7248 // Join to the context table so that we can preload contexts if required.
7249 if ($includecontexts) {
7250 $ctxselect = ', ' . context_helper::get_preload_record_columns_sql('ctx');
7251 $ctxjoin = "LEFT JOIN {context} ctx ON (ctx.instanceid = c.id AND ctx.contextlevel = :contextlevel)";
7252 $params['contextlevel'] = CONTEXT_COURSE;
7253 } else {
7254 $ctxselect = '';
7255 $ctxjoin = '';
7256 }
7257
7258 // Now we need to get all of the courses to search.
7259 // All courses where the user has posted within a forum will be returned.
7260 $sql = "SELECT c.* $ctxselect
7261 FROM {course} c
7262 $ctxjoin
7263 WHERE c.id IN ($subquery)";
7264 $courses = $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
7265 if ($includecontexts) {
7266 array_map('context_helper::preload_from_record', $courses);
7267 }
7268 return $courses;
7269 }
7270
7271 /**
7272 * Gets all of the forums a user has posted in for one or more courses.
7273 *
7274 * @global moodle_database $DB
7275 * @param stdClass $user
7276 * @param array $courseids An array of courseids to search or if not provided
7277 * all courses the user has posted within
7278 * @param bool $discussionsonly If true then only forums where the user has started
7279 * a discussion will be returned.
7280 * @param int $limitfrom The offset of records to return
7281 * @param int $limitnum The number of records to return
7282 * @return array An array of forums the user has posted within in the provided courses
7283 */
7284 function forum_get_forums_user_posted_in($user, array $courseids = null, $discussionsonly = false, $limitfrom = null, $limitnum = null) {
7285 global $DB;
7286
7287 if (!is_null($courseids)) {
7288 list($coursewhere, $params) = $DB->get_in_or_equal($courseids, SQL_PARAMS_NAMED, 'courseid');
7289 $coursewhere = ' AND f.course '.$coursewhere;
7290 } else {
7291 $coursewhere = '';
7292 $params = array();
7293 }
7294 $params['userid'] = $user->id;
7295 $params['forum'] = 'forum';
7296
7297 if ($discussionsonly) {
7298 $join = 'JOIN {forum_discussions} ff ON ff.forum = f.id';
7299 } else {
7300 $join = 'JOIN {forum_discussions} fd ON fd.forum = f.id
7301 JOIN {forum_posts} ff ON ff.discussion = fd.id';
7302 }
7303
7304 $sql = "SELECT f.*, cm.id AS cmid
7305 FROM {forum} f
7306 JOIN {course_modules} cm ON cm.instance = f.id
7307 JOIN {modules} m ON m.id = cm.module
7308 JOIN (
7309 SELECT f.id
7310 FROM {forum} f
7311 {$join}
7312 WHERE ff.userid = :userid
7313 GROUP BY f.id
7314 ) j ON j.id = f.id
7315 WHERE m.name = :forum
7316 {$coursewhere}";
7317
7318 $courseforums = $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
7319 return $courseforums;
7320 }
7321
7322 /**
7323 * Returns posts made by the selected user in the requested courses.
7324 *
7325 * This method can be used to return all of the posts made by the requested user
7326 * within the given courses.
7327 * For each course the access of the current user and requested user is checked
7328 * and then for each post access to the post and forum is checked as well.
7329 *
7330 * This function is safe to use with usercapabilities.
7331 *
7332 * @global moodle_database $DB
7333 * @param stdClass $user The user whose posts we want to get
7334 * @param array $courses The courses to search
7335 * @param bool $musthaveaccess If set to true errors will be thrown if the user
7336 * cannot access one or more of the courses to search
7337 * @param bool $discussionsonly If set to true only discussion starting posts
7338 * will be returned.
7339 * @param int $limitfrom The offset of records to return
7340 * @param int $limitnum The number of records to return
7341 * @return stdClass An object the following properties
7342 * ->totalcount: the total number of posts made by the requested user
7343 * that the current user can see.
7344 * ->courses: An array of courses the current user can see that the
7345 * requested user has posted in.
7346 * ->forums: An array of forums relating to the posts returned in the
7347 * property below.
7348 * ->posts: An array containing the posts to show for this request.
7349 */
7350 function forum_get_posts_by_user($user, array $courses, $musthaveaccess = false, $discussionsonly = false, $limitfrom = 0, $limitnum = 50) {
7351 global $DB, $USER, $CFG;
7352
7353 $return = new stdClass;
7354 $return->totalcount = 0; // The total number of posts that the current user is able to view
7355 $return->courses = array(); // The courses the current user can access
7356 $return->forums = array(); // The forums that the current user can access that contain posts
7357 $return->posts = array(); // The posts to display
7358
7359 // First up a small sanity check. If there are no courses to check we can
7360 // return immediately, there is obviously nothing to search.
7361 if (empty($courses)) {
7362 return $return;
7363 }
7364
7365 // A couple of quick setups
7366 $isloggedin = isloggedin();
7367 $isguestuser = $isloggedin && isguestuser();
7368 $iscurrentuser = $isloggedin && $USER->id == $user->id;
7369
7370 // Checkout whether or not the current user has capabilities over the requested
7371 // user and if so they have the capabilities required to view the requested
7372 // users content.
7373 $usercontext = context_user::instance($user->id, MUST_EXIST);
7374 $hascapsonuser = !$iscurrentuser && $DB->record_exists('role_assignments', array('userid' => $USER->id, 'contextid' => $usercontext->id));
7375 $hascapsonuser = $hascapsonuser && has_all_capabilities(array('moodle/user:viewdetails', 'moodle/user:readuserposts'), $usercontext);
7376
7377 // Before we actually search each course we need to check the user's access to the
7378 // course. If the user doesn't have the appropraite access then we either throw an
7379 // error if a particular course was requested or we just skip over the course.
7380 foreach ($courses as $course) {
7381 $coursecontext = context_course::instance($course->id, MUST_EXIST);
7382 if ($iscurrentuser || $hascapsonuser) {
7383 // If it is the current user, or the current user has capabilities to the
7384 // requested user then all we need to do is check the requested users
7385 // current access to the course.
7386 // Note: There is no need to check group access or anything of the like
7387 // as either the current user is the requested user, or has granted
7388 // capabilities on the requested user. Either way they can see what the
7389 // requested user posted, although its VERY unlikely in the `parent` situation
7390 // that the current user will be able to view the posts in context.
7391 if (!is_viewing($coursecontext, $user) && !is_enrolled($coursecontext, $user)) {
7392 // Need to have full access to a course to see the rest of own info
7393 if ($musthaveaccess) {
7394 print_error('errorenrolmentrequired', 'forum');
7395 }
7396 continue;
7397 }
7398 } else {
7399 // Check whether the current user is enrolled or has access to view the course
7400 // if they don't we immediately have a problem.
7401 if (!can_access_course($course)) {
7402 if ($musthaveaccess) {
7403 print_error('errorenrolmentrequired', 'forum');
7404 }
7405 continue;
7406 }
7407
7408 // Check whether the requested user is enrolled or has access to view the course
7409 // if they don't we immediately have a problem.
7410 if (!can_access_course($course, $user)) {
7411 if ($musthaveaccess) {
7412 print_error('notenrolled', 'forum');
7413 }
7414 continue;
7415 }
7416
7417 // If groups are in use and enforced throughout the course then make sure
7418 // we can meet in at least one course level group.
7419 // Note that we check if either the current user or the requested user have
7420 // the capability to access all groups. This is because with that capability
7421 // a user in group A could post in the group B forum. Grrrr.
7422 if (groups_get_course_groupmode($course) == SEPARATEGROUPS && $course->groupmodeforce
7423 && !has_capability('moodle/site:accessallgroups', $coursecontext) && !has_capability('moodle/site:accessallgroups', $coursecontext, $user->id)) {
7424 // If its the guest user to bad... the guest user cannot access groups
7425 if (!$isloggedin or $isguestuser) {
7426 // do not use require_login() here because we might have already used require_login($course)
7427 if ($musthaveaccess) {
7428 redirect(get_login_url());
7429 }
7430 continue;
7431 }
7432 // Get the groups of the current user
7433 $mygroups = array_keys(groups_get_all_groups($course->id, $USER->id, $course->defaultgroupingid, 'g.id, g.name'));
7434 // Get the groups the requested user is a member of
7435 $usergroups = array_keys(groups_get_all_groups($course->id, $user->id, $course->defaultgroupingid, 'g.id, g.name'));
7436 // Check whether they are members of the same group. If they are great.
7437 $intersect = array_intersect($mygroups, $usergroups);
7438 if (empty($intersect)) {
7439 // But they're not... if it was a specific course throw an error otherwise
7440 // just skip this course so that it is not searched.
7441 if ($musthaveaccess) {
7442 print_error("groupnotamember", '', $CFG->wwwroot."/course/view.php?id=$course->id");
7443 }
7444 continue;
7445 }
7446 }
7447 }
7448 // Woo hoo we got this far which means the current user can search this
7449 // this course for the requested user. Although this is only the course accessibility
7450 // handling that is complete, the forum accessibility tests are yet to come.
7451 $return->courses[$course->id] = $course;
7452 }
7453 // No longer beed $courses array - lose it not it may be big
7454 unset($courses);
7455
7456 // Make sure that we have some courses to search
7457 if (empty($return->courses)) {
7458 // If we don't have any courses to search then the reality is that the current
7459 // user doesn't have access to any courses is which the requested user has posted.
7460 // Although we do know at this point that the requested user has posts.
7461 if ($musthaveaccess) {
7462 print_error('permissiondenied');
7463 } else {
7464 return $return;
7465 }
7466 }
7467
7468 // Next step: Collect all of the forums that we will want to search.
7469 // It is important to note that this step isn't actually about searching, it is
7470 // about determining which forums we can search by testing accessibility.
7471 $forums = forum_get_forums_user_posted_in($user, array_keys($return->courses), $discussionsonly);
7472
7473 // Will be used to build the where conditions for the search
7474 $forumsearchwhere = array();
7475 // Will be used to store the where condition params for the search
7476 $forumsearchparams = array();
7477 // Will record forums where the user can freely access everything
7478 $forumsearchfullaccess = array();
7479 // DB caching friendly
7480 $now = round(time(), -2);
7481 // For each course to search we want to find the forums the user has posted in
7482 // and providing the current user can access the forum create a search condition
7483 // for the forum to get the requested users posts.
7484 foreach ($return->courses as $course) {
7485 // Now we need to get the forums
7486 $modinfo = get_fast_modinfo($course);
7487 if (empty($modinfo->instances['forum'])) {
7488 // hmmm, no forums? well at least its easy... skip!
7489 continue;
7490 }
7491 // Iterate
7492 foreach ($modinfo->get_instances_of('forum') as $forumid => $cm) {
7493 if (!$cm->uservisible or !isset($forums[$forumid])) {
7494 continue;
7495 }
7496 // Get the forum in question
7497 $forum = $forums[$forumid];
7498
7499 // This is needed for functionality later on in the forum code. It is converted to an object
7500 // because the cm_info is readonly from 2.6. This is a dirty hack because some other parts of the
7501 // code were expecting an writeable object. See {@link forum_print_post()}.
7502 $forum->cm = new stdClass();
7503 foreach ($cm as $key => $value) {
7504 $forum->cm->$key = $value;
7505 }
7506
7507 // Check that either the current user can view the forum, or that the
7508 // current user has capabilities over the requested user and the requested
7509 // user can view the discussion
7510 if (!has_capability('mod/forum:viewdiscussion', $cm->context) && !($hascapsonuser && has_capability('mod/forum:viewdiscussion', $cm->context, $user->id))) {
7511 continue;
7512 }
7513
7514 // This will contain forum specific where clauses
7515 $forumsearchselect = array();
7516 if (!$iscurrentuser && !$hascapsonuser) {
7517 // Make sure we check group access
7518 if (groups_get_activity_groupmode($cm, $course) == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $cm->context)) {
7519 $groups = $modinfo->get_groups($cm->groupingid);
7520 $groups[] = -1;
7521 list($groupid_sql, $groupid_params) = $DB->get_in_or_equal($groups, SQL_PARAMS_NAMED, 'grps'.$forumid.'_');
7522 $forumsearchparams = array_merge($forumsearchparams, $groupid_params);
7523 $forumsearchselect[] = "d.groupid $groupid_sql";
7524 }
7525
7526 // hidden timed discussions
7527 if (!empty($CFG->forum_enabletimedposts) && !has_capability('mod/forum:viewhiddentimedposts', $cm->context)) {
7528 $forumsearchselect[] = "(d.userid = :userid{$forumid} OR (d.timestart < :timestart{$forumid} AND (d.timeend = 0 OR d.timeend > :timeend{$forumid})))";
7529 $forumsearchparams['userid'.$forumid] = $user->id;
7530 $forumsearchparams['timestart'.$forumid] = $now;
7531 $forumsearchparams['timeend'.$forumid] = $now;
7532 }
7533
7534 // qanda access
7535 if ($forum->type == 'qanda' && !has_capability('mod/forum:viewqandawithoutposting', $cm->context)) {
7536 // We need to check whether the user has posted in the qanda forum.
7537 $discussionspostedin = forum_discussions_user_has_posted_in($forum->id, $user->id);
7538 if (!empty($discussionspostedin)) {
7539 $forumonlydiscussions = array(); // Holds discussion ids for the discussions the user is allowed to see in this forum.
7540 foreach ($discussionspostedin as $d) {
7541 $forumonlydiscussions[] = $d->id;
7542 }
7543 list($discussionid_sql, $discussionid_params) = $DB->get_in_or_equal($forumonlydiscussions, SQL_PARAMS_NAMED, 'qanda'.$forumid.'_');
7544 $forumsearchparams = array_merge($forumsearchparams, $discussionid_params);
7545 $forumsearchselect[] = "(d.id $discussionid_sql OR p.parent = 0)";
7546 } else {
7547 $forumsearchselect[] = "p.parent = 0";
7548 }
7549
7550 }
7551
7552 if (count($forumsearchselect) > 0) {
7553 $forumsearchwhere[] = "(d.forum = :forum{$forumid} AND ".implode(" AND ", $forumsearchselect).")";
7554 $forumsearchparams['forum'.$forumid] = $forumid;
7555 } else {
7556 $forumsearchfullaccess[] = $forumid;
7557 }
7558 } else {
7559 // The current user/parent can see all of their own posts
7560 $forumsearchfullaccess[] = $forumid;
7561 }
7562 }
7563 }
7564
7565 // If we dont have any search conditions, and we don't have any forums where
7566 // the user has full access then we just return the default.
7567 if (empty($forumsearchwhere) && empty($forumsearchfullaccess)) {
7568 return $return;
7569 }
7570
7571 // Prepare a where condition for the full access forums.
7572 if (count($forumsearchfullaccess) > 0) {
7573 list($fullidsql, $fullidparams) = $DB->get_in_or_equal($forumsearchfullaccess, SQL_PARAMS_NAMED, 'fula');
7574 $forumsearchparams = array_merge($forumsearchparams, $fullidparams);
7575 $forumsearchwhere[] = "(d.forum $fullidsql)";
7576 }
7577
7578 // Prepare SQL to both count and search.
7579 // We alias user.id to useridx because we forum_posts already has a userid field and not aliasing this would break
7580 // oracle and mssql.
7581 $userfields = user_picture::fields('u', null, 'useridx');
7582 $countsql = 'SELECT COUNT(*) ';
7583 $selectsql = 'SELECT p.*, d.forum, d.name AS discussionname, '.$userfields.' ';
7584 $wheresql = implode(" OR ", $forumsearchwhere);
7585
7586 if ($discussionsonly) {
7587 if ($wheresql == '') {
7588 $wheresql = 'p.parent = 0';
7589 } else {
7590 $wheresql = 'p.parent = 0 AND ('.$wheresql.')';
7591 }
7592 }
7593
7594 $sql = "FROM {forum_posts} p
7595 JOIN {forum_discussions} d ON d.id = p.discussion
7596 JOIN {user} u ON u.id = p.userid
7597 WHERE ($wheresql)
7598 AND p.userid = :userid ";
7599 $orderby = "ORDER BY p.modified DESC";
7600 $forumsearchparams['userid'] = $user->id;
7601
7602 // Set the total number posts made by the requested user that the current user can see
7603 $return->totalcount = $DB->count_records_sql($countsql.$sql, $forumsearchparams);
7604 // Set the collection of posts that has been requested
7605 $return->posts = $DB->get_records_sql($selectsql.$sql.$orderby, $forumsearchparams, $limitfrom, $limitnum);
7606
7607 // We need to build an array of forums for which posts will be displayed.
7608 // We do this here to save the caller needing to retrieve them themselves before
7609 // printing these forums posts. Given we have the forums already there is
7610 // practically no overhead here.
7611 foreach ($return->posts as $post) {
7612 if (!array_key_exists($post->forum, $return->forums)) {
7613 $return->forums[$post->forum] = $forums[$post->forum];
7614 }
7615 }
7616
7617 return $return;
7618 }
7619
7620 /**
7621 * Set the per-forum maildigest option for the specified user.
7622 *
7623 * @param stdClass $forum The forum to set the option for.
7624 * @param int $maildigest The maildigest option.
7625 * @param stdClass $user The user object. This defaults to the global $USER object.
7626 * @throws invalid_digest_setting thrown if an invalid maildigest option is provided.
7627 */
7628 function forum_set_user_maildigest($forum, $maildigest, $user = null) {
7629 global $DB, $USER;
7630
7631 if (is_number($forum)) {
7632 $forum = $DB->get_record('forum', array('id' => $forum));
7633 }
7634
7635 if ($user === null) {
7636 $user = $USER;
7637 }
7638
7639 $course = $DB->get_record('course', array('id' => $forum->course), '*', MUST_EXIST);
7640 $cm = get_coursemodule_from_instance('forum', $forum->id, $course->id, false, MUST_EXIST);
7641 $context = context_module::instance($cm->id);
7642
7643 // User must be allowed to see this forum.
7644 require_capability('mod/forum:viewdiscussion', $context, $user->id);
7645
7646 // Validate the maildigest setting.
7647 $digestoptions = forum_get_user_digest_options($user);
7648
7649 if (!isset($digestoptions[$maildigest])) {
7650 throw new moodle_exception('invaliddigestsetting', 'mod_forum');
7651 }
7652
7653 // Attempt to retrieve any existing forum digest record.
7654 $subscription = $DB->get_record('forum_digests', array(
7655 'userid' => $user->id,
7656 'forum' => $forum->id,
7657 ));
7658
7659 // Create or Update the existing maildigest setting.
7660 if ($subscription) {
7661 if ($maildigest == -1) {
7662 $DB->delete_records('forum_digests', array('forum' => $forum->id, 'userid' => $user->id));
7663 } else if ($maildigest !== $subscription->maildigest) {
7664 // Only update the maildigest setting if it's changed.
7665
7666 $subscription->maildigest = $maildigest;
7667 $DB->update_record('forum_digests', $subscription);
7668 }
7669 } else {
7670 if ($maildigest != -1) {
7671 // Only insert the maildigest setting if it's non-default.
7672
7673 $subscription = new stdClass();
7674 $subscription->forum = $forum->id;
7675 $subscription->userid = $user->id;
7676 $subscription->maildigest = $maildigest;
7677 $subscription->id = $DB->insert_record('forum_digests', $subscription);
7678 }
7679 }
7680 }
7681
7682 /**
7683 * Determine the maildigest setting for the specified user against the
7684 * specified forum.
7685 *
7686 * @param Array $digests An array of forums and user digest settings.
7687 * @param stdClass $user The user object containing the id and maildigest default.
7688 * @param int $forumid The ID of the forum to check.
7689 * @return int The calculated maildigest setting for this user and forum.
7690 */
7691 function forum_get_user_maildigest_bulk($digests, $user, $forumid) {
7692 if (isset($digests[$forumid]) && isset($digests[$forumid][$user->id])) {
7693 $maildigest = $digests[$forumid][$user->id];
7694 if ($maildigest === -1) {
7695 $maildigest = $user->maildigest;
7696 }
7697 } else {
7698 $maildigest = $user->maildigest;
7699 }
7700 return $maildigest;
7701 }
7702
7703 /**
7704 * Retrieve the list of available user digest options.
7705 *
7706 * @param stdClass $user The user object. This defaults to the global $USER object.
7707 * @return array The mapping of values to digest options.
7708 */
7709 function forum_get_user_digest_options($user = null) {
7710 global $USER;
7711
7712 // Revert to the global user object.
7713 if ($user === null) {
7714 $user = $USER;
7715 }
7716
7717 $digestoptions = array();
7718 $digestoptions['0'] = get_string('emaildigestoffshort', 'mod_forum');
7719 $digestoptions['1'] = get_string('emaildigestcompleteshort', 'mod_forum');
7720 $digestoptions['2'] = get_string('emaildigestsubjectsshort', 'mod_forum');
7721
7722 // We need to add the default digest option at the end - it relies on
7723 // the contents of the existing values.
7724 $digestoptions['-1'] = get_string('emaildigestdefault', 'mod_forum',
7725 $digestoptions[$user->maildigest]);
7726
7727 // Resort the options to be in a sensible order.
7728 ksort($digestoptions);
7729
7730 return $digestoptions;
7731 }
7732
7733 /**
7734 * Determine the current context if one was not already specified.
7735 *
7736 * If a context of type context_module is specified, it is immediately
7737 * returned and not checked.
7738 *
7739 * @param int $forumid The ID of the forum
7740 * @param context_module $context The current context.
7741 * @return context_module The context determined
7742 */
7743 function forum_get_context($forumid, $context = null) {
7744 global $PAGE;
7745
7746 if (!$context || !($context instanceof context_module)) {
7747 // Find out forum context. First try to take current page context to save on DB query.
7748 if ($PAGE->cm && $PAGE->cm->modname === 'forum' && $PAGE->cm->instance == $forumid
7749 && $PAGE->context->contextlevel == CONTEXT_MODULE && $PAGE->context->instanceid == $PAGE->cm->id) {
7750 $context = $PAGE->context;
7751 } else {
7752 $cm = get_coursemodule_from_instance('forum', $forumid);
7753 $context = \context_module::instance($cm->id);
7754 }
7755 }
7756
7757 return $context;
7758 }
Read-only mirror of the Moodle CVS