Merge branch 'MDL-66625-master' of git://github.com/rezaies/moodle
[moodle.git] / mod / forum / report / summary / classes / summary_table.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * The class for displaying the forum report table.
19  *
20  * @package   forumreport_summary
21  * @copyright 2019 Michael Hawkins <michaelh@moodle.com>
22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 namespace forumreport_summary;
26 defined('MOODLE_INTERNAL') || die();
28 require_once($CFG->libdir . '/tablelib.php');
30 use coding_exception;
31 use table_sql;
33 /**
34  * The class for displaying the forum report table.
35  *
36  * @copyright  2019 Michael Hawkins <michaelh@moodle.com>
37  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
38  */
39 class summary_table extends table_sql {
41     /** Forum filter type */
42     const FILTER_FORUM = 1;
44     /** Groups filter type */
45     const FILTER_GROUPS = 2;
47     /** Table to store summary data extracted from the log table */
48     const LOG_SUMMARY_TEMP_TABLE = 'forum_report_summary_counts';
50     /** @var \stdClass The various SQL segments that will be combined to form queries to fetch various information. */
51     public $sql;
53     /** @var int The number of rows to be displayed per page. */
54     protected $perpage = 25;
56     /** @var \stdClass The course module object of the forum being reported on. */
57     protected $cm;
59     /**
60      * @var int The user ID if only one user's summary will be generated.
61      * This will apply to users without permission to view others' summaries.
62      */
63     protected $userid;
65     /**
66      * @var \core\log\sql_reader|null
67      */
68     protected $logreader = null;
70     /**
71      * @var \context|null
72      */
73     protected $context = null;
75     /**
76      * @var bool
77      */
78     private $showwordcharcounts = null;
80     /**
81      * @var bool Whether the user can see all private replies or not.
82      */
83     protected $canseeprivatereplies;
85     /**
86      * Forum report table constructor.
87      *
88      * @param int $courseid The ID of the course the forum(s) exist within.
89      * @param array $filters Report filters in the format 'type' => [values].
90      * @param bool $bulkoperations Is the user allowed to perform bulk operations?
91      * @param bool $canseeprivatereplies Whether the user can see all private replies or not.
92      */
93     public function __construct(int $courseid, array $filters, bool $bulkoperations, bool $canseeprivatereplies) {
94         global $USER, $OUTPUT;
96         $forumid = $filters['forums'][0];
98         parent::__construct("summaryreport_{$courseid}_{$forumid}");
100         $this->cm = get_coursemodule_from_instance('forum', $forumid, $courseid);
101         $this->context = \context_module::instance($this->cm->id);
102         $this->canseeprivatereplies = $canseeprivatereplies;
104         // Only show their own summary unless they have permission to view all.
105         if (!has_capability('forumreport/summary:viewall', $this->context)) {
106             $this->userid = $USER->id;
107         }
109         $columnheaders = [];
111         if ($bulkoperations) {
112             $mastercheckbox = new \core\output\checkbox_toggleall('summaryreport-table', true, [
113                 'id' => 'select-all-users',
114                 'name' => 'select-all-users',
115                 'label' => get_string('selectall'),
116                 'labelclasses' => 'sr-only',
117                 'classes' => 'm-1',
118                 'checked' => false
119             ]);
120             $columnheaders['select'] = $OUTPUT->render($mastercheckbox);
121         }
123         $columnheaders += [
124             'fullname' => get_string('fullnameuser'),
125             'postcount' => get_string('postcount', 'forumreport_summary'),
126             'replycount' => get_string('replycount', 'forumreport_summary'),
127             'attachmentcount' => get_string('attachmentcount', 'forumreport_summary'),
128         ];
130         $this->logreader = $this->get_internal_log_reader();
131         if ($this->logreader) {
132             $columnheaders['viewcount'] = get_string('viewcount', 'forumreport_summary');
133         }
135         if ($this->show_word_char_counts()) {
136             $columnheaders['wordcount'] = get_string('wordcount', 'forumreport_summary');
137             $columnheaders['charcount'] = get_string('charcount', 'forumreport_summary');
138         }
140         $columnheaders['earliestpost'] = get_string('earliestpost', 'forumreport_summary');
141         $columnheaders['latestpost'] = get_string('latestpost', 'forumreport_summary');
143         $this->define_columns(array_keys($columnheaders));
144         $this->define_headers(array_values($columnheaders));
146         // Define configs.
147         $this->define_table_configs();
149         // Define the basic SQL data and object format.
150         $this->define_base_sql();
152         // Apply relevant filters.
153         $this->apply_filters($filters);
154     }
156     /**
157      * Provides the string name of each filter type.
158      *
159      * @param int $filtertype Type of filter
160      * @return string Name of the filter
161      */
162     public function get_filter_name(int $filtertype): string {
163         $filternames = [
164             self::FILTER_FORUM => 'Forum',
165             self::FILTER_GROUPS => 'Groups',
166         ];
168         return $filternames[$filtertype];
169     }
171     /**
172      * Generate the select column.
173      *
174      * @param \stdClass $data
175      * @return string
176      */
177     public function col_select($data) {
178         global $OUTPUT;
180         $checkbox = new \core\output\checkbox_toggleall('summaryreport-table', false, [
181             'classes' => 'usercheckbox m-1',
182             'id' => 'user' . $data->userid,
183             'name' => 'user' . $data->userid,
184             'checked' => false,
185             'label' => get_string('selectitem', 'moodle', fullname($data)),
186             'labelclasses' => 'accesshide',
187         ]);
189         return $OUTPUT->render($checkbox);
190     }
192     /**
193      * Generate the fullname column.
194      *
195      * @param \stdClass $data The row data.
196      * @return string User's full name.
197      */
198     public function col_fullname($data): string {
199         if ($this->is_downloading()) {
200             return fullname($data);
201         }
203         global $OUTPUT;
204         return $OUTPUT->user_picture($data, array('size' => 35, 'courseid' => $this->cm->course, 'includefullname' => true));
205     }
207     /**
208      * Generate the postcount column.
209      *
210      * @param \stdClass $data The row data.
211      * @return int number of discussion posts made by user.
212      */
213     public function col_postcount(\stdClass $data): int {
214         return $data->postcount;
215     }
217     /**
218      * Generate the replycount column.
219      *
220      * @param \stdClass $data The row data.
221      * @return int number of replies made by user.
222      */
223     public function col_replycount(\stdClass $data): int {
224         return $data->replycount;
225     }
227     /**
228      * Generate the attachmentcount column.
229      *
230      * @param \stdClass $data The row data.
231      * @return int number of files attached to posts by user.
232      */
233     public function col_attachmentcount(\stdClass $data): int {
234         return $data->attachmentcount;
235     }
237     /**
238      * Generate the earliestpost column.
239      *
240      * @param \stdClass $data The row data.
241      * @return string Timestamp of user's earliest post, or a dash if no posts exist.
242      */
243     public function col_earliestpost(\stdClass $data): string {
244         global $USER;
246         return empty($data->earliestpost) ? '-' : userdate($data->earliestpost, "", \core_date::get_user_timezone($USER));
247     }
249     /**
250      * Generate the latestpost column.
251      *
252      * @param \stdClass $data The row data.
253      * @return string Timestamp of user's most recent post, or a dash if no posts exist.
254      */
255     public function col_latestpost(\stdClass $data): string {
256         global $USER;
258         return empty($data->latestpost) ? '-' : userdate($data->latestpost, "", \core_date::get_user_timezone($USER));
259     }
261     /**
262      * Override the default implementation to set a decent heading level.
263      *
264      * @return void.
265      */
266     public function print_nothing_to_display(): void {
267         global $OUTPUT;
269         echo $OUTPUT->heading(get_string('nothingtodisplay'), 4);
270     }
272     /**
273      * Query the db. Store results in the table object for use by build_table.
274      *
275      * @param int $pagesize Size of page for paginated displayed table.
276      * @param bool $useinitialsbar Overridden but unused.
277      * @return void
278      */
279     public function query_db($pagesize, $useinitialsbar = false): void {
280         global $DB;
282         // Set up pagination if not downloading the whole report.
283         if (!$this->is_downloading()) {
284             $totalsql = $this->get_full_sql(false);
286             // Set up pagination.
287             $totalrows = $DB->count_records_sql($totalsql, $this->sql->params);
288             $this->pagesize($pagesize, $totalrows);
289         }
291         // Fetch the data.
292         $sql = $this->get_full_sql();
294         // Only paginate when not downloading.
295         if (!$this->is_downloading()) {
296             $this->rawdata = $DB->get_records_sql($sql, $this->sql->params, $this->get_page_start(), $this->get_page_size());
297         } else {
298             $this->rawdata = $DB->get_records_sql($sql, $this->sql->params);
299         }
300     }
302     /**
303      * Adds the relevant SQL to apply a filter to the report.
304      *
305      * @param int $filtertype Filter type as defined by class constants.
306      * @param array $values Optional array of values passed into the filter type.
307      * @return void
308      * @throws coding_exception
309      */
310     public function add_filter(int $filtertype, array $values = []): void {
311         global $DB;
313         $paramcounterror = false;
315         switch($filtertype) {
316             case self::FILTER_FORUM:
317                 // Requires exactly one forum ID.
318                 if (count($values) != 1) {
319                     $paramcounterror = true;
320                 } else {
321                     // No select fields required - displayed in title.
322                     // No extra joins required, forum is already joined.
323                     $this->sql->filterwhere .= ' AND f.id = :forumid';
324                     $this->sql->params['forumid'] = $values[0];
325                 }
327                 break;
329             case self::FILTER_GROUPS:
330                 // Skip adding filter if not applied, or all options are selected.
331                 if ($this->is_filtered_by_groups($values)) {
332                     // Include users without groups if that option (-1) is selected.
333                     $nonekey = array_search(-1, $values, true);
335                     // Users within selected groups or not in any groups are included.
336                     if ($nonekey !== false && count($values) > 1) {
337                         unset($values[$nonekey]);
338                         list($groupidin, $groupidparams) = $DB->get_in_or_equal($values, SQL_PARAMS_NAMED, 'groupid');
340                         // No select fields required.
341                         // No joins required (handled by where to prevent data duplication).
342                         $this->sql->filterwhere .= "
343                             AND (u.id =
344                                 (SELECT gm.userid
345                                    FROM {groups_members} gm
346                                   WHERE gm.userid = u.id
347                                     AND gm.groupid {$groupidin}
348                                GROUP BY gm.userid
349                                   LIMIT 1)
350                             OR
351                                 (SELECT nogm.userid
352                                    FROM mdl_groups_members nogm
353                                   WHERE nogm.userid = u.id
354                                GROUP BY nogm.userid
355                                   LIMIT 1)
356                             IS NULL)";
357                         $this->sql->params += $groupidparams;
359                     } else if ($nonekey !== false) {
360                         // Only users within no groups are included.
361                         unset($values[$nonekey]);
363                         // No select fields required.
364                         $this->sql->filterfromjoins .= " LEFT JOIN {groups_members} nogm ON nogm.userid = u.id";
365                         $this->sql->filterwhere .= " AND nogm.id IS NULL";
367                     } else if (!empty($values)) {
368                         // Only users within selected groups are included.
369                         list($groupidin, $groupidparams) = $DB->get_in_or_equal($values, SQL_PARAMS_NAMED, 'groupid');
371                         // No select fields required.
372                         // No joins required (handled by where to prevent data duplication).
373                         $this->sql->filterwhere .= "
374                             AND u.id = (
375                                  SELECT gm.userid
376                                    FROM {groups_members} gm
377                                   WHERE gm.userid = u.id
378                                     AND gm.groupid {$groupidin}
379                                GROUP BY gm.userid
380                                   LIMIT 1)";
381                         $this->sql->params += $groupidparams;
382                     }
383                 }
385                 break;
387             default:
388                 throw new coding_exception("Report filter type '{$filtertype}' not found.");
389                 break;
390         }
392         if ($paramcounterror) {
393             $filtername = $this->get_filter_name($filtertype);
394             throw new coding_exception("An invalid number of values have been passed for the '{$filtername}' filter.");
395         }
396     }
398     /**
399      * Define various table config options.
400      *
401      * @return void.
402      */
403     protected function define_table_configs(): void {
404         $this->collapsible(false);
405         $this->sortable(true, 'firstname', SORT_ASC);
406         $this->pageable(true);
407         $this->is_downloadable(true);
408         $this->no_sorting('select');
409         $this->set_attribute('id', 'forumreport_summary_table');
410     }
412     /**
413      * Define the object to store all for the table SQL and initialises the base SQL required.
414      *
415      * @return void.
416      */
417     protected function define_base_sql(): void {
418         global $USER;
420         $this->sql = new \stdClass();
422         $userfields = get_extra_user_fields($this->context);
423         $userfieldssql = \user_picture::fields('u', $userfields);
425         // Define base SQL query format.
426         $this->sql->basefields = ' ue.userid AS userid,
427                                    e.courseid AS courseid,
428                                    f.id as forumid,
429                                    SUM(CASE WHEN p.parent = 0 THEN 1 ELSE 0 END) AS postcount,
430                                    SUM(CASE WHEN p.parent != 0 THEN 1 ELSE 0 END) AS replycount,
431                                    ' . $userfieldssql . ',
432                                    SUM(CASE WHEN att.attcount IS NULL THEN 0 ELSE att.attcount END) AS attachmentcount,
433                                    MIN(p.created) AS earliestpost,
434                                    MAX(p.created) AS latestpost';
436         // Handle private replies.
437         $privaterepliessql = '';
438         $privaterepliesparams = [];
439         if (!$this->canseeprivatereplies) {
440             $privaterepliessql = ' AND (p.privatereplyto = :privatereplyto
441                                         OR p.userid = :privatereplyfrom
442                                         OR p.privatereplyto = 0)';
443             $privaterepliesparams['privatereplyto'] = $USER->id;
444             $privaterepliesparams['privatereplyfrom'] = $USER->id;
445         }
447         $this->sql->basefromjoins = '    {enrol} e
448                                     JOIN {user_enrolments} ue ON ue.enrolid = e.id
449                                     JOIN {user} u ON u.id = ue.userid
450                                     JOIN {forum} f ON f.course = e.courseid
451                                     JOIN {forum_discussions} d ON d.forum = f.id
452                                LEFT JOIN {forum_posts} p ON p.discussion =  d.id
453                                      AND p.userid = ue.userid
454                                      ' . $privaterepliessql . '
455                                LEFT JOIN (
456                                             SELECT COUNT(fi.id) AS attcount, fi.itemid AS postid, fi.userid
457                                               FROM {files} fi
458                                              WHERE fi.component = :component
459                                                AND fi.filesize > 0
460                                           GROUP BY fi.itemid, fi.userid
461                                          ) att ON att.postid = p.id
462                                          AND att.userid = ue.userid';
464         $this->sql->basewhere = 'e.courseid = :courseid';
466         $this->sql->basegroupby = 'ue.userid, e.courseid, f.id, u.id, ' . $userfieldssql;
468         if ($this->logreader) {
469             $this->fill_log_summary_temp_table($this->context->id);
471             $this->sql->basefields .= ', CASE WHEN tmp.viewcount IS NOT NULL THEN tmp.viewcount ELSE 0 END AS viewcount';
472             $this->sql->basefromjoins .= ' LEFT JOIN {' . self::LOG_SUMMARY_TEMP_TABLE . '} tmp ON tmp.userid = u.id ';
473             $this->sql->basegroupby .= ', tmp.viewcount';
474         }
476         if ($this->show_word_char_counts()) {
477             // All p.wordcount values should be NOT NULL, this CASE WHEN is an extra just-in-case.
478             $this->sql->basefields .= ', SUM(CASE WHEN p.wordcount IS NOT NULL THEN p.wordcount ELSE 0 END) AS wordcount';
479             $this->sql->basefields .= ', SUM(CASE WHEN p.charcount IS NOT NULL THEN p.charcount ELSE 0 END) AS charcount';
480         }
482         $this->sql->params = [
483             'component' => 'mod_forum',
484             'courseid' => $this->cm->course,
485         ] + $privaterepliesparams;
487         // Handle if a user is limited to viewing their own summary.
488         if (!empty($this->userid)) {
489             $this->sql->basewhere .= ' AND ue.userid = :userid';
490             $this->sql->params['userid'] = $this->userid;
491         }
493         // Filter values will be populated separately where required.
494         $this->sql->filterfields = '';
495         $this->sql->filterfromjoins = '';
496         $this->sql->filterwhere = '';
497         $this->sql->filtergroupby = '';
498     }
500     /**
501      * Overriding the parent method because it should not be used here.
502      * Filters are applied, so the structure of $this->sql is now different to the way this is set up in the parent.
503      *
504      * @param string $fields Unused.
505      * @param string $from Unused.
506      * @param string $where Unused.
507      * @param array $params Unused.
508      * @return void.
509      *
510      * @throws coding_exception
511      */
512     public function set_sql($fields, $from, $where, array $params = []) {
513         throw new coding_exception('The set_sql method should not be used by the summary_table class.');
514     }
516     /**
517      * Convenience method to call a number of methods for you to display the table.
518      * Overrides the parent so SQL for filters is handled.
519      *
520      * @param int $pagesize Number of rows to fetch.
521      * @param bool $useinitialsbar Whether to include the initials bar with the table.
522      * @param string $downloadhelpbutton Unused.
523      *
524      * @return void.
525      */
526     public function out($pagesize, $useinitialsbar, $downloadhelpbutton = ''): void {
527         global $DB;
529         if (!$this->columns) {
530             $sql = $this->get_full_sql();
532             $onerow = $DB->get_record_sql($sql, $this->sql->params, IGNORE_MULTIPLE);
534             // If columns is not set, define columns as the keys of the rows returned from the db.
535             $this->define_columns(array_keys((array)$onerow));
536             $this->define_headers(array_keys((array)$onerow));
537         }
539         $this->setup();
540         $this->query_db($pagesize, $useinitialsbar);
541         $this->build_table();
542         $this->close_recordset();
543         $this->finish_output();
544     }
546     /**
547      * Apply the relevant filters to the report.
548      *
549      * @param array $filters Report filters in the format 'type' => [values].
550      * @return void.
551      */
552     protected function apply_filters(array $filters): void {
553         // Apply the forums filter.
554         $this->add_filter(self::FILTER_FORUM, $filters['forums']);
556         // Apply groups filter.
557         $this->add_filter(self::FILTER_GROUPS, $filters['groups']);
558     }
560     /**
561      * Prepares a complete SQL statement from the base query and any filters defined.
562      *
563      * @param bool $fullselect Whether to select all relevant columns.
564      *              False selects a count only (used to calculate pagination).
565      * @return string The complete SQL statement.
566      */
567     protected function get_full_sql(bool $fullselect = true): string {
568         $groupby = '';
569         $orderby = '';
571         if ($fullselect) {
572             $selectfields = "{$this->sql->basefields}
573                              {$this->sql->filterfields}";
575             $groupby = ' GROUP BY ' . $this->sql->basegroupby . $this->sql->filtergroupby;
577             if (($sort = $this->get_sql_sort())) {
578                 $orderby = " ORDER BY {$sort}";
579             }
580         } else {
581             $selectfields = 'COUNT(DISTINCT(ue.userid))';
582         }
584         $sql = "SELECT {$selectfields}
585                   FROM {$this->sql->basefromjoins}
586                        {$this->sql->filterfromjoins}
587                  WHERE {$this->sql->basewhere}
588                        {$this->sql->filterwhere}
589                        {$groupby}
590                        {$orderby}";
592         return $sql;
593     }
595     /**
596      * Returns an internal and enabled log reader.
597      *
598      * @return \core\log\sql_reader|false
599      */
600     protected function get_internal_log_reader(): ?\core\log\sql_reader {
601         global $DB;
603         $readers = get_log_manager()->get_readers('core\log\sql_reader');
604         foreach ($readers as $reader) {
606             // If reader is not a sql_internal_table_reader and not legacy store then return.
607             if (!($reader instanceof \core\log\sql_internal_table_reader) && !($reader instanceof logstore_legacy\log\store)) {
608                 continue;
609             }
610             $logreader = $reader;
611         }
613         if (empty($logreader)) {
614             return null;
615         }
617         return $logreader;
618     }
620     /**
621      * Fills the log summary temp table.
622      *
623      * @param int $contextid
624      * @return null
625      */
626     protected function fill_log_summary_temp_table(int $contextid) {
627         global $DB;
629         $this->create_log_summary_temp_table();
631         if ($this->logreader instanceof logstore_legacy\log\store) {
632             $logtable = 'log';
633             // Anonymous actions are never logged in legacy log.
634             $nonanonymous = '';
635         } else {
636             $logtable = $this->logreader->get_internal_log_table_name();
637             $nonanonymous = 'AND anonymous = 0';
638         }
639         $params = ['contextid' => $contextid];
640         $sql = "INSERT INTO {" . self::LOG_SUMMARY_TEMP_TABLE . "} (userid, viewcount)
641                      SELECT userid, COUNT(*) AS viewcount
642                        FROM {" . $logtable . "}
643                       WHERE contextid = :contextid
644                             $nonanonymous
645                    GROUP BY userid";
646         $DB->execute($sql, $params);
647     }
649     /**
650      * Creates a temp table to store summary data from the log table for this request.
651      *
652      * @return null
653      */
654     protected function create_log_summary_temp_table() {
655         global $DB;
657         $dbman = $DB->get_manager();
658         $temptablename = self::LOG_SUMMARY_TEMP_TABLE;
659         $xmldbtable = new \xmldb_table($temptablename);
660         $xmldbtable->add_field('userid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, null);
661         $xmldbtable->add_field('viewcount', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, null);
662         $xmldbtable->add_key('primary', XMLDB_KEY_PRIMARY, array('userid'));
664         $dbman->create_temp_table($xmldbtable);
665     }
667     /**
668      * Check whether the groups filter will be applied by checking whether the number of groups selected
669      * matches the total number of options available (all groups plus no groups option).
670      *
671      * @param array $groups The group IDs selected.
672      * @return bool
673      */
674     protected function is_filtered_by_groups(array $groups): bool {
675         static $groupsavailablecount = null;
677         if (empty($groups)) {
678             return false;
679         }
681         // Find total number of options available (groups plus 'no groups'), if not already fetched.
682         if (is_null($groupsavailablecount)) {
683             $groupsavailablecount = 1 + count(groups_get_activity_allowed_groups($this->cm));
684         }
686         return (count($groups) < $groupsavailablecount);
687     }
689     /**
690      * Download the summary report in the selected format.
691      *
692      * @param string $format The format to download the report.
693      */
694     public function download($format) {
695         $filename = 'summary_report_' . userdate(time(), get_string('backupnameformat', 'langconfig'),
696                 99, false);
698         $this->is_downloading($format, $filename);
699         $this->out($this->perpage, false);
700     }
702     /*
703      * Should the word / char counts be displayed?
704      *
705      * We don't want to show word/char columns if there is any null value because this means
706      * that they have not been calculated yet.
707      * @return bool
708      */
709     protected function show_word_char_counts(): bool {
710         global $DB;
712         if (is_null($this->showwordcharcounts)) {
713             // This should be really fast.
714             $sql = "SELECT 'x'
715                       FROM {forum_posts} fp
716                       JOIN {forum_discussions} fd ON fd.id = fp.discussion
717                      WHERE fd.forum = :forumid AND (fp.wordcount IS NULL OR fp.charcount IS NULL)";
719             if ($DB->record_exists_sql($sql, ['forumid' => $this->cm->instance])) {
720                 $this->showwordcharcounts = false;
721             } else {
722                 $this->showwordcharcounts = true;
723             }
724         }
726         return $this->showwordcharcounts;
727     }