Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

declare(strict_types=1);

namespace core_reportbuilder\table;

use core\output\notification;

use html_writer;

use moodle_exception;

use moodle_url;

use stdClass;

use core_reportbuilder\{datasource, manager};

use core_reportbuilder\local\models\report;

use core_reportbuilder\local\report\column;

use core_reportbuilder\output\column_aggregation_editable;

use core_reportbuilder\output\column_heading_editable;

/**

 * Custom report dynamic table class

 *

 * @package     core_reportbuilder

 * @copyright   2021 David Matamoros <davidmc@moodle.com>

 * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class custom_report_table extends base_report_table {

    /** @var datasource $report */

    protected $report;

    /** @var string Unique ID prefix for the table */

    private const UNIQUEID_PREFIX = 'custom-report-table-';

    /** @var bool Whether report is being edited (we don't want user filters/sorting to be applied when editing) */

    protected const REPORT_EDITING = true;

    /** @var float $querytimestart Time we began executing table SQL */

    private $querytimestart = 0.0;

    /**

     * Table constructor. Note that the passed unique ID value must match the pattern "custom-report-table-(\d+)" so that

     * dynamic updates continue to load the same report

     *

     * @param string $uniqueid

     * @param string $download

     * @throws moodle_exception For invalid unique ID

     */

    public function __construct(string $uniqueid, string $download = '') {

        if (!preg_match('/^' . self::UNIQUEID_PREFIX . '(?<id>\d+)$/', $uniqueid, $matches)) {

            throw new moodle_exception('invalidcustomreportid', 'core_reportbuilder', '', null, $uniqueid);

        }

        parent::__construct($uniqueid);

        $this->define_baseurl(new moodle_url('/reportbuilder/edit.php', ['id' => $matches['id']]));

        // Load the report persistent, and accompanying report instance.

        $this->persistent = new report($matches['id']);

        $this->report = manager::get_report_from_persistent($this->persistent);

        $fields = $groupby = [];

        $maintable = $this->report->get_main_table();

        $maintablealias = $this->report->get_main_table_alias();

        $joins = $this->report->get_joins();

        [$where, $params] = $this->report->get_base_condition();

        $this->set_attribute('data-region', 'reportbuilder-table');

        $this->set_attribute('class', $this->attributes['class'] . ' reportbuilder-table');

        // Download options.

        $this->showdownloadbuttonsat = [TABLE_P_BOTTOM];

        $this->is_downloading($download ?? null, $this->persistent->get_formatted_name());

        // Retrieve all report columns, exit early if there are none. Defining empty columns prevents errors during out().

        $columns = $this->get_active_columns();

        if (empty($columns)) {

            $this->init_sql("{$maintablealias}.*", "{{$maintable}} {$maintablealias}", $joins, '1=0', []);

            $this->define_columns([0]);

            return;

        }

        // If we are aggregating any columns, we should group by the remaining ones.

        $aggregatedcolumns = array_filter($columns, fn(column $column): bool => !empty($column->get_aggregation()));

        $hasaggregatedcolumns = !empty($aggregatedcolumns);

        // Also take account of the report setting to show unique rows (only if no columns are being aggregated).

        $showuniquerows = !$hasaggregatedcolumns && $this->persistent->get('uniquerows');

        $columnheaders = $columnsattributes = [];

        foreach ($columns as $column) {

            $columnheading = $column->get_persistent()->get_formatted_heading($this->report->get_context());

            $columnheaders[$column->get_column_alias()] = $columnheading !== '' ? $columnheading : $column->get_title();

            // We need to determine for each column whether we should group by its fields, to support aggregation.

            $columnaggregation = $column->get_aggregation();

            if ($showuniquerows || ($hasaggregatedcolumns && (empty($columnaggregation) || $columnaggregation::column_groupby()))) {

                $groupby = array_merge($groupby, $column->get_groupby_sql());

            }

            // Add each columns fields, joins and params to our report.

            $fields = array_merge($fields, $column->get_fields());

            $joins = array_merge($joins, $column->get_joins());

            $params = array_merge($params, $column->get_params());

            // Disable sorting for some columns.

            if (!$column->get_is_sortable()) {

                $this->no_sorting($column->get_column_alias());

            }

            // Add column attributes needed for card view.

            $settings = $this->report->get_settings_values();

            $showfirsttitle = $settings['cardview_showfirsttitle'] ?? false;

            $visiblecolumns = max($settings['cardview_visiblecolumns'] ?? 1, count($this->columns));

            if ($showfirsttitle || $column->get_persistent()->get('columnorder') > 1) {

                $column->add_attributes(['data-cardtitle' => $columnheaders[$column->get_column_alias()]]);

            }

            if ($column->get_persistent()->get('columnorder') > $visiblecolumns) {

                $column->add_attributes(['data-cardviewhidden' => '']);

            }

            // Generate column attributes to be included in each cell.

            $columnsattributes[$column->get_column_alias()] = $column->get_attributes();

        }

        $this->define_columns(array_keys($columnheaders));

        $this->define_headers(array_values($columnheaders));

        // Add column attributes to the table.

        $this->set_columnsattributes($columnsattributes);

        // Table configuration.

        $this->initialbars(false);

        $this->collapsible(false);

        $this->pageable(true);

        $this->set_default_per_page($this->report->get_default_per_page());

        // Initialise table SQL properties.

        $this->set_report_editing(static::REPORT_EDITING);

        $fieldsql = implode(', ', $fields);

        $this->init_sql($fieldsql, "{{$maintable}} {$maintablealias}", $joins, $where, $params, $groupby);

    }

    /**

     * Return a new instance of the class for given report ID

     *

     * @param int $reportid

     * @param string $download

     * @return static

     */

    public static function create(int $reportid, string $download = ''): self {

        return new static(self::UNIQUEID_PREFIX . $reportid, $download);

    }

    /**

     * Get user preferred sort columns, overriding those of parent. If user has no preferences then use report defaults

     *

     * @return array

     */

    public function get_sort_columns(): array {

        $sortcolumns = parent::get_sort_columns();

        if ($this->editing || empty($sortcolumns)) {

            $sortcolumns = [];

            $columns = $this->get_active_columns();

            // We need to sort the columns by the configured sorting order.

            usort($columns, static function(column $a, column $b): int {

                return ($a->get_persistent()->get('sortorder') < $b->get_persistent()->get('sortorder')) ? -1 : 1;

            });

            foreach ($columns as $column) {

                $persistent = $column->get_persistent();

                if ($column->get_is_sortable() && $persistent->get('sortenabled')) {

                    $sortcolumns[$column->get_column_alias()] = $persistent->get('sortdirection');

                }

            }

        }

        return $sortcolumns;

    }

    /**

     * Format each row of returned data, executing defined callbacks for the row and each column

     *

     * @param array|stdClass $row

     * @return array

     */

    public function format_row($row) {

        $columns = $this->get_active_columns();

        $formattedrow = [];

        foreach ($columns as $column) {

            $formattedrow[$column->get_column_alias()] = $column->format_value((array) $row);

        }

        return $formattedrow;

    }

    /**

     * Download is disabled when editing the report

     *

     * @return string

     */

    public function download_buttons(): string {

        return '';

    }

    /**

     * Get the columns of the custom report, returned instances being valid and available for the user

     *

     * @return column[]

     */

    protected function get_active_columns(): array {

        return $this->report->get_active_columns();

    }

    /**

     * Override parent method for printing headers so we can render our custom controls in each cell

     */

    public function print_headers() {

        global $OUTPUT, $PAGE;

        $columns = $this->get_active_columns();

        if (empty($columns)) {

            return;

        }

        $columns = array_values($columns);

        $renderer = $PAGE->get_renderer('core');

        echo html_writer::start_tag('thead');

        echo html_writer::start_tag('tr');

        foreach ($this->headers as $index => $title) {

            $column = $columns[$index];

            $headingeditable = new column_heading_editable(0, $column->get_persistent());

            $aggregationeditable = new column_aggregation_editable(0, $column->get_persistent());

            // Render table header cell, with all editing controls.

            $headercell = $OUTPUT->render_from_template('core_reportbuilder/table_header_cell', [

                'entityname' => $this->report->get_entity_title($column->get_entity_name()),

                'name' => $column->get_title(),

                'headingeditable' => $headingeditable->render($renderer),

                'aggregationeditable' => $aggregationeditable->render($renderer),

                'movetitle' => get_string('movecolumn', 'core_reportbuilder', $column->get_title()),

            ]);

            echo html_writer::tag('th', $headercell, [

                'class' => 'border-end border-start',

                'scope' => 'col',

                'data-region' => 'column-header',

                'data-column-id' => $column->get_persistent()->get('id'),

                'data-column-name' => $column->get_title(),

                'data-column-position' => $index + 1,

            ]);

        }

        echo html_writer::end_tag('tr');

        echo html_writer::end_tag('thead');

    }

    /**

     * Override print_nothing_to_display to ensure that column headers are always added.

     */

    public function print_nothing_to_display() {

        global $OUTPUT;

        $this->start_html();

        $this->print_headers();

        echo html_writer::end_tag('table');

        echo html_writer::end_tag('div');

        $this->wrap_html_finish();

        // With the live editing disabled we need to notify user that data is shown only in preview mode.

        if ($this->editing && !self::show_live_editing()) {

            $notificationmsg = get_string('customreportsliveeditingdisabled', 'core_reportbuilder');

            $notificationtype = notification::NOTIFY_WARNING;

        } else {

            $notificationmsg = get_string('nothingtodisplay');

            $notificationtype = notification::NOTIFY_INFO;

        }

        $notification = (new notification($notificationmsg, $notificationtype, false))

            ->set_extra_classes(['mt-3']);

        echo $OUTPUT->render($notification);

        echo $this->get_dynamic_table_html_end();

    }

    /**

     * Provide additional table debugging during editing

     */

    public function wrap_html_finish(): void {

        global $OUTPUT;

        if ($this->editing && debugging('', DEBUG_DEVELOPER)) {

            $params = array_map(static function(string $param, $value): array {

                return ['param' => $param, 'value' => var_export($value, true)];

            }, array_keys($this->sql->params), $this->sql->params);

            echo $OUTPUT->render_from_template('core_reportbuilder/local/report/debug', [

                'query' => $this->get_table_sql(),

                'params' => $params,

                'duration' => $this->querytimestart ?

                    format_time($this->querytimestart - microtime(true)) : null,

            ]);

        }

    }

    /**

     * Override get_row_cells_html to add an extra cell with the toggle button for card view.

     *

     * @param string $rowid

     * @param array $row

     * @param array|null $suppresslastrow

     * @return string

     */

    public function get_row_cells_html(string $rowid, array $row, ?array $suppresslastrow): string {

        $html = parent::get_row_cells_html($rowid, $row, $suppresslastrow);

        // Add extra 'td' in the row with card toggle button (only visible in card view).

        $visiblecolumns = $this->report->get_settings_values()['cardview_visiblecolumns'] ?? 1;

        if ($visiblecolumns < count($this->columns)) {

            $buttonicon = html_writer::tag('i', '', ['class' => 'fa fa-angle-down']);

            // We need a cleaned version (without tags/entities) of the first row column to use as toggle button.

            $rowfirstcolumn = strip_tags((string) reset($row));

            $buttontitle = $rowfirstcolumn !== ''

                ? get_string('showhide', 'core_reportbuilder', html_entity_decode($rowfirstcolumn, ENT_COMPAT))

                : get_string('showhidecard', 'core_reportbuilder');

            $button = html_writer::tag('button', $buttonicon, [

                'type' => 'button',

                'class' => 'btn collapsed',

                'title' => $buttontitle,

                'data-bs-toggle' => 'collapse',

                'data-action' => 'toggle-card'

            ]);

            $html .= html_writer::tag('td', $button, ['class' => 'card-toggle d-none']);

        }

        return $html;

    }

    /**

     * Overriding this method to handle live editing setting.

     * @param int $pagesize

     * @param bool $useinitialsbar

     * @param string $downloadhelpbutton

     */

    public function out($pagesize, $useinitialsbar, $downloadhelpbutton = '') {

        $this->pagesize = $pagesize;

        $this->setup();

        // If the live editing setting is disabled, we not need to fetch custom report data except in preview mode.

        if (!$this->editing || self::show_live_editing()) {

            $this->querytimestart = microtime(true);

            $this->query_db($pagesize, $useinitialsbar);

            $this->build_table();

            $this->close_recordset();

        }

        $this->finish_output();

    }

    /**

     * Whether or not report data should be included in the table while in editing mode

     *

     * @return bool

     */

    private static function show_live_editing(): bool {

        global $CFG;

        return !empty($CFG->customreportsliveediting);

    }

    /**

     * Check if the user has the capability to access this table.

     *

     * @return bool Return true if capability check passed.

     */

    public function has_capability(): bool {

        return \core_reportbuilder\permission::can_edit_report($this->persistent);

    }

}