weekly release 4.0dev
[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     /** Dates filter type */
48     const FILTER_DATES = 3;
50     /** Table to store summary data extracted from the log table */
51     const LOG_SUMMARY_TEMP_TABLE = 'forum_report_summary_counts';
53     /** Default number of rows to display per page */
54     const DEFAULT_PER_PAGE = 50;
56     /** @var \stdClass The various SQL segments that will be combined to form queries to fetch various information. */
57     public $sql;
59     /** @var int The number of rows to be displayed per page. */
60     protected $perpage = self::DEFAULT_PER_PAGE;
62     /** @var array The values available for pagination size per page. */
63     protected $perpageoptions = [50, 100, 200];
65     /** @var int The course ID containing the forum(s) being reported on. */
66     protected $courseid;
68     /** @var bool True if reporting on all forums in course user has access to, false if reporting on a single forum */
69     protected $iscoursereport = false;
71     /** @var bool True if user has access to all forums in the course (and is running course report), otherwise false. */
72     protected $accessallforums = false;
74     /** @var \stdClass The course module object(s) of the forum(s) being reported on. */
75     protected $cms = [];
77     /**
78      * @var int The user ID if only one user's summary will be generated.
79      * This will apply to users without permission to view others' summaries.
80      */
81     protected $userid;
83     /**
84      * @var \core\log\sql_reader|null
85      */
86     protected $logreader = null;
88     /**
89      * @var array of \context objects for the forums included in the report.
90      */
91     protected $forumcontexts = [];
93     /**
94      * @var context_course|context_module The context where the report is being run (either a specific forum or the course).
95      */
96     protected $userfieldscontext = null;
98     /** @var bool Whether the user has the capability/capabilities to perform bulk operations. */
99     protected $allowbulkoperations = false;
101     /**
102      * @var bool
103      */
104     private $showwordcharcounts = null;
106     /**
107      * @var bool Whether the user can see all private replies or not.
108      */
109     protected $canseeprivatereplies;
111     /**
112      * @var array Validated filter data, for use in GET parameters by export links.
113      */
114     protected $exportfilterdata = [];
116     /**
117      * Forum report table constructor.
118      *
119      * @param int $courseid The ID of the course the forum(s) exist within.
120      * @param array $filters Report filters in the format 'type' => [values].
121      * @param bool $allowbulkoperations Is the user allowed to perform bulk operations?
122      * @param bool $canseeprivatereplies Whether the user can see all private replies or not.
123      * @param int $perpage The number of rows to display per page.
124      * @param bool $canexport Is the user allowed to export records?
125      * @param bool $iscoursereport Whether the user is running a course level report
126      * @param bool $accessallforums If user is running a course level report, do they have access to all forums in the course?
127      */
128     public function __construct(int $courseid, array $filters, bool $allowbulkoperations,
129             bool $canseeprivatereplies, int $perpage, bool $canexport, bool $iscoursereport, bool $accessallforums) {
130         global $OUTPUT;
132         $uniqueid = $courseid . ($iscoursereport ? '' : '_' . $filters['forums'][0]);
133         parent::__construct("summaryreport_{$uniqueid}");
135         $this->courseid = $courseid;
136         $this->iscoursereport = $iscoursereport;
137         $this->accessallforums = $accessallforums;
138         $this->allowbulkoperations = $allowbulkoperations;
139         $this->canseeprivatereplies = $canseeprivatereplies;
140         $this->perpage = $perpage;
142         $this->set_forum_properties($filters['forums']);
144         $columnheaders = [];
146         if ($allowbulkoperations) {
147             $mastercheckbox = new \core\output\checkbox_toggleall('summaryreport-table', true, [
148                 'id' => 'select-all-users',
149                 'name' => 'select-all-users',
150                 'label' => get_string('selectall'),
151                 'labelclasses' => 'sr-only',
152                 'classes' => 'm-1',
153                 'checked' => false
154             ]);
155             $columnheaders['select'] = $OUTPUT->render($mastercheckbox);
156         }
158         $columnheaders += [
159             'fullname' => get_string('fullnameuser'),
160             'postcount' => get_string('postcount', 'forumreport_summary'),
161             'replycount' => get_string('replycount', 'forumreport_summary'),
162             'attachmentcount' => get_string('attachmentcount', 'forumreport_summary'),
163         ];
165         $this->logreader = $this->get_internal_log_reader();
166         if ($this->logreader) {
167             $columnheaders['viewcount'] = get_string('viewcount', 'forumreport_summary');
168         }
170         if ($this->show_word_char_counts()) {
171             $columnheaders['wordcount'] = get_string('wordcount', 'forumreport_summary');
172             $columnheaders['charcount'] = get_string('charcount', 'forumreport_summary');
173         }
175         $columnheaders['earliestpost'] = get_string('earliestpost', 'forumreport_summary');
176         $columnheaders['latestpost'] = get_string('latestpost', 'forumreport_summary');
178         if ($canexport) {
179             $columnheaders['export'] = get_string('exportposts', 'forumreport_summary');
180         }
182         $this->define_columns(array_keys($columnheaders));
183         $this->define_headers(array_values($columnheaders));
185         // Define configs.
186         $this->define_table_configs();
188         // Apply relevant filters.
189         $this->define_base_filter_sql();
190         $this->apply_filters($filters);
192         // Define the basic SQL data and object format.
193         $this->define_base_sql();
194     }
196     /**
197      * Sets properties that are determined by forum filter values.
198      *
199      * @param array $forumids The forum IDs passed in by the filter.
200      * @return void
201      */
202     protected function set_forum_properties(array $forumids): void {
203         global $USER;
205         // Course context if reporting on all forums in the course the user has access to.
206         if ($this->iscoursereport) {
207             $this->userfieldscontext = \context_course::instance($this->courseid);
208         }
210         foreach ($forumids as $forumid) {
211             $cm = get_coursemodule_from_instance('forum', $forumid, $this->courseid);
212             $this->cms[] = $cm;
213             $this->forumcontexts[$cm->id] = \context_module::instance($cm->id);
215             // Set forum context if not reporting on course.
216             if (!isset($this->userfieldscontext)) {
217                 $this->userfieldscontext = $this->forumcontexts[$cm->id];
218             }
220             // Only show own summary unless they have permission to view all in every forum being reported.
221             if (empty($this->userid) && !has_capability('forumreport/summary:viewall', $this->forumcontexts[$cm->id])) {
222                 $this->userid = $USER->id;
223             }
224         }
225     }
227     /**
228      * Provides the string name of each filter type, to be used by errors.
229      * Note: This does not use language strings as the value is injected into error strings.
230      *
231      * @param int $filtertype Type of filter
232      * @return string Name of the filter
233      */
234     protected function get_filter_name(int $filtertype): string {
235         $filternames = [
236             self::FILTER_FORUM => 'Forum',
237             self::FILTER_GROUPS => 'Groups',
238             self::FILTER_DATES => 'Dates',
239         ];
241         return $filternames[$filtertype];
242     }
244     /**
245      * Generate the select column.
246      *
247      * @param \stdClass $data
248      * @return string
249      */
250     public function col_select($data) {
251         global $OUTPUT;
253         $checkbox = new \core\output\checkbox_toggleall('summaryreport-table', false, [
254             'classes' => 'usercheckbox m-1',
255             'id' => 'user' . $data->userid,
256             'name' => 'user' . $data->userid,
257             'checked' => false,
258             'label' => get_string('selectitem', 'moodle', fullname($data)),
259             'labelclasses' => 'accesshide',
260         ]);
262         return $OUTPUT->render($checkbox);
263     }
265     /**
266      * Generate the fullname column.
267      *
268      * @param \stdClass $data The row data.
269      * @return string User's full name.
270      */
271     public function col_fullname($data): string {
272         if ($this->is_downloading()) {
273             return fullname($data);
274         }
276         global $OUTPUT;
277         return $OUTPUT->user_picture($data, array('courseid' => $this->courseid, 'includefullname' => true));
278     }
280     /**
281      * Generate the postcount column.
282      *
283      * @param \stdClass $data The row data.
284      * @return int number of discussion posts made by user.
285      */
286     public function col_postcount(\stdClass $data): int {
287         return $data->postcount;
288     }
290     /**
291      * Generate the replycount column.
292      *
293      * @param \stdClass $data The row data.
294      * @return int number of replies made by user.
295      */
296     public function col_replycount(\stdClass $data): int {
297         return $data->replycount;
298     }
300     /**
301      * Generate the attachmentcount column.
302      *
303      * @param \stdClass $data The row data.
304      * @return int number of files attached to posts by user.
305      */
306     public function col_attachmentcount(\stdClass $data): int {
307         return $data->attachmentcount;
308     }
310     /**
311      * Generate the earliestpost column.
312      *
313      * @param \stdClass $data The row data.
314      * @return string Timestamp of user's earliest post, or a dash if no posts exist.
315      */
316     public function col_earliestpost(\stdClass $data): string {
317         global $USER;
319         return empty($data->earliestpost) ? '-' : userdate($data->earliestpost, "", \core_date::get_user_timezone($USER));
320     }
322     /**
323      * Generate the latestpost column.
324      *
325      * @param \stdClass $data The row data.
326      * @return string Timestamp of user's most recent post, or a dash if no posts exist.
327      */
328     public function col_latestpost(\stdClass $data): string {
329         global $USER;
331         return empty($data->latestpost) ? '-' : userdate($data->latestpost, "", \core_date::get_user_timezone($USER));
332     }
334     /**
335      * Generate the export column.
336      *
337      * @param \stdClass $data The row data.
338      * @return string The link to export content belonging to the row.
339      */
340     public function col_export(\stdClass $data): string {
341         global $OUTPUT;
343         // If no posts, nothing to export.
344         if (empty($data->earliestpost)) {
345             return '';
346         }
348         $params = [
349             'id' => $this->cms[0]->instance, // Forum id.
350             'userids[]' => $data->userid, // User id.
351         ];
353         // Add relevant filter params.
354         foreach ($this->exportfilterdata as $name => $data) {
355             if (is_array($data)) {
356                 foreach ($data as $key => $value) {
357                     $params["{$name}[{$key}]"] = $value;
358                 }
359             } else {
360                 $params[$name] = $data;
361             }
362         }
364         $buttoncontext = [
365             'url' => new \moodle_url('/mod/forum/export.php', $params),
366             'label' => get_string('exportpostslabel', 'forumreport_summary', fullname($data)),
367         ];
369         return $OUTPUT->render_from_template('forumreport_summary/export_link_button', $buttoncontext);
370     }
372     /**
373      * Override the default implementation to set a decent heading level.
374      *
375      * @return void.
376      */
377     public function print_nothing_to_display(): void {
378         global $OUTPUT;
380         echo $OUTPUT->heading(get_string('nothingtodisplay'), 4);
381     }
383     /**
384      * Query the db. Store results in the table object for use by build_table.
385      *
386      * @param int $pagesize Size of page for paginated displayed table.
387      * @param bool $useinitialsbar Overridden but unused.
388      * @return void
389      */
390     public function query_db($pagesize, $useinitialsbar = false): void {
391         global $DB;
393         // Set up pagination if not downloading the whole report.
394         if (!$this->is_downloading()) {
395             $totalsql = $this->get_full_sql(false);
397             // Set up pagination.
398             $totalrows = $DB->count_records_sql($totalsql, $this->sql->params);
399             $this->pagesize($pagesize, $totalrows);
400         }
402         // Fetch the data.
403         $sql = $this->get_full_sql();
405         // Only paginate when not downloading.
406         if (!$this->is_downloading()) {
407             $this->rawdata = $DB->get_records_sql($sql, $this->sql->params, $this->get_page_start(), $this->get_page_size());
408         } else {
409             $this->rawdata = $DB->get_records_sql($sql, $this->sql->params);
410         }
411     }
413     /**
414      * Adds the relevant SQL to apply a filter to the report.
415      *
416      * @param int $filtertype Filter type as defined by class constants.
417      * @param array $values Optional array of values passed into the filter type.
418      * @return void
419      * @throws coding_exception
420      */
421     public function add_filter(int $filtertype, array $values = []): void {
422         global $DB;
424         $paramcounterror = false;
426         switch($filtertype) {
427             case self::FILTER_FORUM:
428                 // Requires at least one forum ID.
429                 if (empty($values)) {
430                     $paramcounterror = true;
431                 } else {
432                     // No select fields required - displayed in title.
433                     // No extra joins required, forum is already joined.
434                     list($forumidin, $forumidparams) = $DB->get_in_or_equal($values, SQL_PARAMS_NAMED);
435                     $this->sql->filterwhere .= " AND f.id {$forumidin}";
436                     $this->sql->params += $forumidparams;
437                 }
439                 break;
441             case self::FILTER_GROUPS:
442                 // Filter data to only include content within specified groups (and/or no groups).
443                 // Additionally, only display users who can post within the selected option(s).
445                 // Only filter by groups the user has access to.
446                 $groups = $this->get_filter_groups($values);
448                 // Skip adding filter if not applied, or all valid options are selected.
449                 if (!empty($groups)) {
450                     list($groupidin, $groupidparams) = $DB->get_in_or_equal($groups, SQL_PARAMS_NAMED);
452                     // Posts within selected groups and/or not in any groups (group ID -1) are included.
453                     // No user filtering as anyone enrolled can potentially post to unrestricted discussions.
454                     if (array_search(-1, $groups) !== false) {
455                         $this->sql->filterwhere .= " AND d.groupid {$groupidin}";
456                         $this->sql->params += $groupidparams;
458                     } else {
459                         // Only posts and users within selected groups are included.
460                         list($groupusersin, $groupusersparams) = $DB->get_in_or_equal($groups, SQL_PARAMS_NAMED);
462                         // No joins required (handled by where to prevent data duplication).
463                         $this->sql->filterwhere .= "
464                             AND u.id IN (
465                                 SELECT gm.userid
466                                   FROM {groups_members} gm
467                                  WHERE gm.groupid {$groupusersin}
468                             )
469                             AND d.groupid {$groupidin}";
470                         $this->sql->params += $groupusersparams + $groupidparams;
471                     }
472                 }
474                 break;
476             case self::FILTER_DATES:
477                 if (!isset($values['from']['enabled']) || !isset($values['to']['enabled']) ||
478                         ($values['from']['enabled'] && !isset($values['from']['timestamp'])) ||
479                         ($values['to']['enabled'] && !isset($values['to']['timestamp']))) {
480                     $paramcounterror = true;
481                 } else {
482                     $this->sql->filterbase['dates'] = '';
483                     $this->sql->filterbase['dateslog'] = '';
484                     $this->sql->filterbase['dateslogparams'] = [];
486                     // From date.
487                     if ($values['from']['enabled']) {
488                         // If the filter was enabled, include the date restriction.
489                         // Needs to form part of the base join to posts, so will be injected by define_base_sql().
490                         $this->sql->filterbase['dates'] .= " AND p.created >= :fromdate";
491                         $this->sql->params['fromdate'] = $values['from']['timestamp'];
492                         $this->sql->filterbase['dateslog'] .= ' AND timecreated >= :fromdate';
493                         $this->sql->filterbase['dateslogparams']['fromdate'] = $values['from']['timestamp'];
494                         $this->exportfilterdata['timestampfrom'] = $values['from']['timestamp'];
495                     }
497                     // To date.
498                     if ($values['to']['enabled']) {
499                         // If the filter was enabled, include the date restriction.
500                         // Needs to form part of the base join to posts, so will be injected by define_base_sql().
501                         $this->sql->filterbase['dates'] .= " AND p.created <= :todate";
502                         $this->sql->params['todate'] = $values['to']['timestamp'];
503                         $this->sql->filterbase['dateslog'] .= ' AND timecreated <= :todate';
504                         $this->sql->filterbase['dateslogparams']['todate'] = $values['to']['timestamp'];
505                         $this->exportfilterdata['timestampto'] = $values['to']['timestamp'];
506                     }
507                 }
509                 break;
510             default:
511                 throw new coding_exception("Report filter type '{$filtertype}' not found.");
512                 break;
513         }
515         if ($paramcounterror) {
516             $filtername = $this->get_filter_name($filtertype);
517             throw new coding_exception("An invalid number of values have been passed for the '{$filtername}' filter.");
518         }
519     }
521     /**
522      * Define various table config options.
523      *
524      * @return void.
525      */
526     protected function define_table_configs(): void {
527         $this->collapsible(false);
528         $this->sortable(true, 'firstname', SORT_ASC);
529         $this->pageable(true);
530         $this->is_downloadable(true);
531         $this->no_sorting('select');
532         $this->no_sorting('export');
533         $this->set_attribute('id', 'forumreport_summary_table');
534         $this->sql = new \stdClass();
535         $this->sql->params = [];
536     }
538     /**
539      * Define the object to store all for the table SQL and initialises the base SQL required.
540      *
541      * @return void.
542      */
543     protected function define_base_sql(): void {
544         global $USER;
546         // TODO Does not support custom user profile fields (MDL-70456).
547         $userfieldsapi = \core_user\fields::for_identity($this->userfieldscontext, false)->with_userpic();
548         $userfieldssql = $userfieldsapi->get_sql('u', false, '', '', false)->selects;
550         // Define base SQL query format.
551         $this->sql->basefields = ' ue.userid AS userid,
552                                    e.courseid AS courseid,
553                                    SUM(CASE WHEN p.parent = 0 THEN 1 ELSE 0 END) AS postcount,
554                                    SUM(CASE WHEN p.parent != 0 THEN 1 ELSE 0 END) AS replycount,
555                                    ' . $userfieldssql . ',
556                                    SUM(CASE WHEN att.attcount IS NULL THEN 0 ELSE att.attcount END) AS attachmentcount,
557                                    MIN(p.created) AS earliestpost,
558                                    MAX(p.created) AS latestpost';
560         // Handle private replies.
561         $privaterepliessql = '';
562         $privaterepliesparams = [];
563         if (!$this->canseeprivatereplies) {
564             $privaterepliessql = ' AND (p.privatereplyto = :privatereplyto
565                                         OR p.userid = :privatereplyfrom
566                                         OR p.privatereplyto = 0)';
567             $privaterepliesparams['privatereplyto'] = $USER->id;
568             $privaterepliesparams['privatereplyfrom'] = $USER->id;
569         }
571         $this->sql->basefromjoins = '    {enrol} e
572                                     JOIN {user_enrolments} ue ON ue.enrolid = e.id
573                                     JOIN {user} u ON u.id = ue.userid
574                                     JOIN {forum} f ON f.course = e.courseid
575                                     JOIN {forum_discussions} d ON d.forum = f.id
576                                LEFT JOIN {forum_posts} p ON p.discussion =  d.id
577                                      AND p.userid = ue.userid
578                                      ' . $privaterepliessql
579                                        . $this->sql->filterbase['dates'] . '
580                                LEFT JOIN (
581                                             SELECT COUNT(fi.id) AS attcount, fi.itemid AS postid, fi.userid
582                                               FROM {files} fi
583                                              WHERE fi.component = :component
584                                                AND fi.filesize > 0
585                                           GROUP BY fi.itemid, fi.userid
586                                          ) att ON att.postid = p.id
587                                          AND att.userid = ue.userid';
589         $this->sql->basewhere = 'e.courseid = :courseid';
591         $this->sql->basegroupby = 'ue.userid, e.courseid, u.id, ' . $userfieldssql;
593         if ($this->logreader) {
594             $this->fill_log_summary_temp_table();
596             $this->sql->basefields .= ', CASE WHEN tmp.viewcount IS NOT NULL THEN tmp.viewcount ELSE 0 END AS viewcount';
597             $this->sql->basefromjoins .= ' LEFT JOIN {' . self::LOG_SUMMARY_TEMP_TABLE . '} tmp ON tmp.userid = u.id ';
598             $this->sql->basegroupby .= ', tmp.viewcount';
599         }
601         if ($this->show_word_char_counts()) {
602             // All p.wordcount values should be NOT NULL, this CASE WHEN is an extra just-in-case.
603             $this->sql->basefields .= ', SUM(CASE WHEN p.wordcount IS NOT NULL THEN p.wordcount ELSE 0 END) AS wordcount';
604             $this->sql->basefields .= ', SUM(CASE WHEN p.charcount IS NOT NULL THEN p.charcount ELSE 0 END) AS charcount';
605         }
607         $this->sql->params += [
608             'component' => 'mod_forum',
609             'courseid' => $this->courseid,
610         ] + $privaterepliesparams;
612         // Handle if a user is limited to viewing their own summary.
613         if (!empty($this->userid)) {
614             $this->sql->basewhere .= ' AND ue.userid = :userid';
615             $this->sql->params['userid'] = $this->userid;
616         }
617     }
619     /**
620      * Instantiate the properties to store filter values.
621      *
622      * @return void.
623      */
624     protected function define_base_filter_sql(): void {
625         // Filter values will be populated separately where required.
626         $this->sql->filterfields = '';
627         $this->sql->filterfromjoins = '';
628         $this->sql->filterwhere = '';
629         $this->sql->filtergroupby = '';
630     }
632     /**
633      * Overriding the parent method because it should not be used here.
634      * Filters are applied, so the structure of $this->sql is now different to the way this is set up in the parent.
635      *
636      * @param string $fields Unused.
637      * @param string $from Unused.
638      * @param string $where Unused.
639      * @param array $params Unused.
640      * @return void.
641      *
642      * @throws coding_exception
643      */
644     public function set_sql($fields, $from, $where, array $params = []) {
645         throw new coding_exception('The set_sql method should not be used by the summary_table class.');
646     }
648     /**
649      * Convenience method to call a number of methods for you to display the table.
650      * Overrides the parent so SQL for filters is handled.
651      *
652      * @param int $pagesize Number of rows to fetch.
653      * @param bool $useinitialsbar Whether to include the initials bar with the table.
654      * @param string $downloadhelpbutton Unused.
655      *
656      * @return void.
657      */
658     public function out($pagesize, $useinitialsbar, $downloadhelpbutton = ''): void {
659         global $DB;
661         if (!$this->columns) {
662             $sql = $this->get_full_sql();
664             $onerow = $DB->get_record_sql($sql, $this->sql->params, IGNORE_MULTIPLE);
666             // If columns is not set, define columns as the keys of the rows returned from the db.
667             $this->define_columns(array_keys((array)$onerow));
668             $this->define_headers(array_keys((array)$onerow));
669         }
671         $this->setup();
672         $this->query_db($pagesize, $useinitialsbar);
673         $this->build_table();
674         $this->close_recordset();
675         $this->finish_output();
677         // Drop the temp table when necessary.
678         if ($this->logreader) {
679             $this->drop_log_summary_temp_table();
680         }
681     }
683     /**
684      * Apply the relevant filters to the report.
685      *
686      * @param array $filters Report filters in the format 'type' => [values].
687      * @return void.
688      */
689     protected function apply_filters(array $filters): void {
690         // Apply the forums filter if not reporting on every forum in a course.
691         if (!$this->accessallforums) {
692             $this->add_filter(self::FILTER_FORUM, $filters['forums']);
693         }
695         // Apply groups filter.
696         $this->add_filter(self::FILTER_GROUPS, $filters['groups']);
698         // Apply dates filter.
699         $datevalues = [
700             'from' => $filters['datefrom'],
701             'to' => $filters['dateto'],
702         ];
703         $this->add_filter(self::FILTER_DATES, $datevalues);
704     }
706     /**
707      * Prepares a complete SQL statement from the base query and any filters defined.
708      *
709      * @param bool $fullselect Whether to select all relevant columns.
710      *              False selects a count only (used to calculate pagination).
711      * @return string The complete SQL statement.
712      */
713     protected function get_full_sql(bool $fullselect = true): string {
714         $groupby = '';
715         $orderby = '';
717         if ($fullselect) {
718             $selectfields = "{$this->sql->basefields}
719                              {$this->sql->filterfields}";
721             $groupby = ' GROUP BY ' . $this->sql->basegroupby . $this->sql->filtergroupby;
723             if (($sort = $this->get_sql_sort())) {
724                 $orderby = " ORDER BY {$sort}";
725             }
726         } else {
727             $selectfields = 'COUNT(DISTINCT(ue.userid))';
728         }
730         $sql = "SELECT {$selectfields}
731                   FROM {$this->sql->basefromjoins}
732                        {$this->sql->filterfromjoins}
733                  WHERE {$this->sql->basewhere}
734                        {$this->sql->filterwhere}
735                        {$groupby}
736                        {$orderby}";
738         return $sql;
739     }
741     /**
742      * Returns an internal and enabled log reader.
743      *
744      * @return \core\log\sql_reader|false
745      */
746     protected function get_internal_log_reader(): ?\core\log\sql_reader {
747         global $DB;
749         $readers = get_log_manager()->get_readers('core\log\sql_reader');
750         foreach ($readers as $reader) {
752             // If reader is not a sql_internal_table_reader and not legacy store then return.
753             if (!($reader instanceof \core\log\sql_internal_table_reader) && !($reader instanceof logstore_legacy\log\store)) {
754                 continue;
755             }
756             $logreader = $reader;
757         }
759         if (empty($logreader)) {
760             return null;
761         }
763         return $logreader;
764     }
766     /**
767      * Fills the log summary temp table.
768      *
769      * @return null
770      */
771     protected function fill_log_summary_temp_table() {
772         global $DB;
774         $this->create_log_summary_temp_table();
776         if ($this->logreader instanceof logstore_legacy\log\store) {
777             $logtable = 'log';
778             // Anonymous actions are never logged in legacy log.
779             $nonanonymous = '';
780         } else {
781             $logtable = $this->logreader->get_internal_log_table_name();
782             $nonanonymous = 'AND anonymous = 0';
783         }
785         // Apply dates filter if applied.
786         $datewhere = $this->sql->filterbase['dateslog'] ?? '';
787         $dateparams = $this->sql->filterbase['dateslogparams'] ?? [];
789         $contextids = [];
791         foreach ($this->forumcontexts as $forumcontext) {
792             $contextids[] = $forumcontext->id;
793         }
795         list($contextidin, $contextidparams) = $DB->get_in_or_equal($contextids, SQL_PARAMS_NAMED);
797         $params = $contextidparams + $dateparams;
798         $sql = "INSERT INTO {" . self::LOG_SUMMARY_TEMP_TABLE . "} (userid, viewcount)
799                      SELECT userid, COUNT(*) AS viewcount
800                        FROM {" . $logtable . "}
801                       WHERE contextid {$contextidin}
802                             $datewhere
803                             $nonanonymous
804                    GROUP BY userid";
805         $DB->execute($sql, $params);
806     }
808     /**
809      * Creates a temp table to store summary data from the log table for this request.
810      *
811      * @return null
812      */
813     protected function create_log_summary_temp_table() {
814         global $DB;
816         $dbman = $DB->get_manager();
817         $temptablename = self::LOG_SUMMARY_TEMP_TABLE;
818         $xmldbtable = new \xmldb_table($temptablename);
819         $xmldbtable->add_field('userid', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, null);
820         $xmldbtable->add_field('viewcount', XMLDB_TYPE_INTEGER, 10, null, XMLDB_NOTNULL, null, null);
821         $xmldbtable->add_key('primary', XMLDB_KEY_PRIMARY, array('userid'));
823         $dbman->create_temp_table($xmldbtable);
824     }
826     /**
827      * Drops the temp table.
828      *
829      * This should be called once the processing for the summary table has been done.
830      */
831     protected function drop_log_summary_temp_table(): void {
832         global $DB;
834         // Drop the temp table if it exists.
835         $temptable = new \xmldb_table(self::LOG_SUMMARY_TEMP_TABLE);
836         $dbman = $DB->get_manager();
837         if ($dbman->table_exists($temptable)) {
838             $dbman->drop_table($temptable);
839         }
840     }
842     /**
843      * Get the final list of groups to filter by, based on the groups submitted,
844      * and those the user has access to.
845      *
846      *
847      * @param array $groups The group IDs submitted.
848      * @return array Group objects of groups to use in groups filter.
849      *                If no filtering required (all groups selected), returns [].
850      */
851     protected function get_filter_groups(array $groups): array {
852         global $USER;
854         $usergroups = groups_get_all_groups($this->courseid, $USER->id);
855         $coursegroupsobj = groups_get_all_groups($this->courseid);
856         $allgroups = false;
857         $allowedgroupsobj = [];
858         $allowedgroups = [];
859         $filtergroups = [];
861         foreach ($this->cms as $cm) {
862             // Only need to check for all groups access if not confirmed by a previous check.
863             if (!$allgroups) {
864                 $groupmode = groups_get_activity_groupmode($cm);
866                 // If no groups mode enabled on the forum, nothing to prepare.
867                 if (!in_array($groupmode, [VISIBLEGROUPS, SEPARATEGROUPS])) {
868                     continue;
869                 }
871                 $aag = has_capability('moodle/site:accessallgroups', $this->forumcontexts[$cm->id]);
873                 if ($groupmode == VISIBLEGROUPS || $aag) {
874                     $allgroups = true;
876                     // All groups in course fetched, no need to continue checking for others.
877                     break;
878                 }
879             }
880         }
882         if ($allgroups) {
883             $nogroups = new \stdClass();
884             $nogroups->id = -1;
885             $nogroups->name = get_string('groupsnone');
887             // Any groups and no groups.
888             $allowedgroupsobj = $coursegroupsobj + [$nogroups];
889         } else {
890             $allowedgroupsobj = $usergroups;
891         }
893         foreach ($allowedgroupsobj as $group) {
894             $allowedgroups[] = $group->id;
895         }
897         // If not all groups in course are selected, filter by allowed groups submitted.
898         if (!empty($groups)) {
899             if (!empty(array_diff($allowedgroups, $groups))) {
900                 $filtergroups = array_intersect($groups, $allowedgroups);
901             } else {
902                 $coursegroups = [];
904                 foreach ($coursegroupsobj as $group) {
905                     $coursegroups[] = $group->id;
906                 }
908                 // If user's 'all groups' is a subset of the course groups, filter by all groups available to them.
909                 if (!empty(array_diff($coursegroups, $allowedgroups))) {
910                     $filtergroups = $allowedgroups;
911                 }
912             }
913         }
915         return $filtergroups;
916     }
918     /**
919      * Download the summary report in the selected format.
920      *
921      * @param string $format The format to download the report.
922      */
923     public function download($format) {
924         $filename = 'summary_report_' . userdate(time(), get_string('backupnameformat', 'langconfig'),
925                 99, false);
927         $this->is_downloading($format, $filename);
928         $this->out($this->perpage, false);
929     }
931     /*
932      * Should the word / char counts be displayed?
933      *
934      * We don't want to show word/char columns if there is any null value because this means
935      * that they have not been calculated yet.
936      * @return bool
937      */
938     protected function show_word_char_counts(): bool {
939         global $DB;
941         if (is_null($this->showwordcharcounts)) {
942             $forumids = [];
944             foreach ($this->cms as $cm) {
945                 $forumids[] = $cm->instance;
946             }
948             list($forumidin, $forumidparams) = $DB->get_in_or_equal($forumids, SQL_PARAMS_NAMED);
950             // This should be really fast.
951             $sql = "SELECT 'x'
952                       FROM {forum_posts} fp
953                       JOIN {forum_discussions} fd ON fd.id = fp.discussion
954                      WHERE fd.forum {$forumidin} AND (fp.wordcount IS NULL OR fp.charcount IS NULL)";
956             if ($DB->record_exists_sql($sql, $forumidparams)) {
957                 $this->showwordcharcounts = false;
958             } else {
959                 $this->showwordcharcounts = true;
960             }
961         }
963         return $this->showwordcharcounts;
964     }
966     /**
967      * Fetch the number of items to be displayed per page.
968      *
969      * @return int
970      */
971     public function get_perpage(): int {
972         return $this->perpage;
973     }
975     /**
976      * Overriding method to render the bulk actions and items per page pagination options directly below the table.
977      *
978      * @return void
979      */
980     public function wrap_html_finish(): void {
981         global $OUTPUT;
983         $data = new \stdClass();
984         $data->showbulkactions = $this->allowbulkoperations;
986         if ($data->showbulkactions) {
987             $data->id = 'formactionid';
988             $data->attributes = [
989                 [
990                     'name' => 'data-action',
991                     'value' => 'toggle'
992                 ],
993                 [
994                     'name' => 'data-togglegroup',
995                     'value' => 'summaryreport-table'
996                 ],
997                 [
998                     'name' => 'data-toggle',
999                     'value' => 'action'
1000                 ],
1001                 [
1002                     'name' => 'disabled',
1003                     'value' => true
1004                 ]
1005             ];
1006             $data->actions = [
1007                 [
1008                     'value' => '#messageselect',
1009                     'name' => get_string('messageselectadd')
1010                 ]
1011             ];
1012         }
1014         // Include the pagination size selector.
1015         $perpageoptions = array_combine($this->perpageoptions, $this->perpageoptions);
1016         $selected = in_array($this->perpage, $this->perpageoptions) ? $this->perpage : $this->perpageoptions[0];
1017         $perpageselect = new \single_select(new \moodle_url(''), 'perpage',
1018                 $perpageoptions, $selected, null, 'selectperpage');
1019         $perpageselect->set_label(get_string('perpage', 'moodle'));
1021         $data->perpage = $perpageselect->export_for_template($OUTPUT);
1023         echo $OUTPUT->render_from_template('forumreport_summary/bulk_action_menu', $data);
1024     }