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/>.

/**

 * @package    core

 * @subpackage lib

 * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}

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

 */

defined('MOODLE_INTERNAL') || die();

/**#@+

 * These constants relate to the table's handling of URL parameters.

 */

define('TABLE_VAR_SORT',   1);

define('TABLE_VAR_HIDE',   2);

define('TABLE_VAR_SHOW',   3);

define('TABLE_VAR_IFIRST', 4);

define('TABLE_VAR_ILAST',  5);

define('TABLE_VAR_PAGE',   6);

define('TABLE_VAR_RESET',  7);

define('TABLE_VAR_DIR',    8);

/**#@-*/

/**#@+

 * Constants that indicate whether the paging bar for the table

 * appears above or below the table.

 */

define('TABLE_P_TOP',    1);

define('TABLE_P_BOTTOM', 2);

/**#@-*/

/**

 * Constant that defines the 'Show all' page size.

 */

define('TABLE_SHOW_ALL_PAGE_SIZE', 5000);

use core\dataformat;

use core_table\local\filter\filterset;

/**

 * @package   moodlecore

 * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}

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

 */

class flexible_table {

    var $uniqueid        = NULL;

    var $attributes      = array();

    var $headers         = array();

    /**

     * @var string A column which should be considered as a header column.

     */

    protected $headercolumn = null;

    /**

     * @var string For create header with help icon.

     */

    private $helpforheaders = array();

    var $columns         = array();

    var $column_style    = array();

    var $column_class    = array();

    var $column_suppress = array();

    var $column_nosort   = array('userpic');

    private $column_textsort = array();

    /**

     * @var array The sticky attribute of each table column.

     */

    protected $columnsticky = [];

    /** @var boolean Stores if setup has already been called on this flixible table. */

    var $setup           = false;

    var $baseurl         = NULL;

    var $request         = array();

    /** @var string[] Columns that are expected to contain a users fullname.  */

    protected $userfullnamecolumns = ['fullname'];

    /** @var array[] Attributes for each column  */

    private $columnsattributes = [];

    /**

     * @var bool Whether or not to store table properties in the user_preferences table.

     */

    private $persistent = false;

    var $is_collapsible = false;

    var $is_sortable    = false;

    /**

     * @var array The fields to sort.

     */

    protected $sortdata;

    /** @var string The manually set first name initial preference */

    protected $ifirst;

    /** @var string The manually set last name initial preference */

    protected $ilast;

    var $use_pages      = false;

    var $use_initials   = false;

    var $maxsortkeys = 2;

    var $pagesize    = 30;

    var $currpage    = 0;

    var $totalrows   = 0;

    var $currentrow  = 0;

    var $sort_default_column = NULL;

    var $sort_default_order  = SORT_ASC;

    /** @var integer The defeult per page size for the table. */

    private $defaultperpage = 30;

    /**

     * Array of positions in which to display download controls.

     */

    var $showdownloadbuttonsat= array(TABLE_P_TOP);

    /**

     * @var string Key of field returned by db query that is the id field of the

     * user table or equivalent.

     */

    public $useridfield = 'id';

    /**

     * @var string which download plugin to use. Default '' means none - print

     * html table with paging. Property set by is_downloading which typically

     * passes in cleaned data from $

     */

    var $download  = '';

    /**

     * @var bool whether data is downloadable from table. Determines whether

     * to display download buttons. Set by method downloadable().

     */

    var $downloadable = false;

    /**

     * @var bool Has start output been called yet?

     */

    var $started_output = false;

    /** @var table_dataformat_export_format */

    var $exportclass = null;

    /**

     * @var array For storing user-customised table properties in the user_preferences db table.

     */

    private $prefs = array();

    /** @var string $sheettitle */

    protected $sheettitle;

    /** @var string $filename */

    protected $filename;

    /** @var array $hiddencolumns List of hidden columns. */

    protected $hiddencolumns;

    /** @var bool $resetting Whether the table preferences is resetting. */

    protected $resetting;

    /**

     * @var string $caption The caption of table

     */

    public $caption;

    /**

     * @var array $captionattributes The caption attributes of table

     */

    public $captionattributes;

    /**

     * @var filterset The currently applied filerset

     * This is required for dynamic tables, but can be used by other tables too if desired.

     */

    protected $filterset = null;

    /**

     * Constructor

     * @param string $uniqueid all tables have to have a unique id, this is used

     *      as a key when storing table properties like sort order in the session.

     */

    function __construct($uniqueid) {

        $this->uniqueid = $uniqueid;

        $this->request  = array(

            TABLE_VAR_SORT   => 'tsort',

            TABLE_VAR_HIDE   => 'thide',

            TABLE_VAR_SHOW   => 'tshow',

            TABLE_VAR_IFIRST => 'tifirst',

            TABLE_VAR_ILAST  => 'tilast',

            TABLE_VAR_PAGE   => 'page',

            TABLE_VAR_RESET  => 'treset',

            TABLE_VAR_DIR    => 'tdir',

        );

    }

    /**

     * Call this to pass the download type. Use :

     *         $download = optional_param('download', '', PARAM_ALPHA);

     * To get the download type. We assume that if you call this function with

     * params that this table's data is downloadable, so we call is_downloadable

     * for you (even if the param is '', which means no download this time.

     * Also you can call this method with no params to get the current set

     * download type.

     * @param string|null $download type of dataformat for export.

     * @param string $filename filename for downloads without file extension.

     * @param string $sheettitle title for downloaded data.

     * @return string download dataformat type.

     */

    function is_downloading($download = null, $filename='', $sheettitle='') {

        if ($download!==null) {

            $this->sheettitle = $sheettitle;

            $this->is_downloadable(true);

            $this->download = $download;

            $this->filename = clean_filename($filename);

            $this->export_class_instance();

        }

        return $this->download;

    }

    /**

     * Get, and optionally set, the export class.

     * @param table_dataformat_export_format $exportclass (optional) if passed, set the table to use this export class.

     * @return table_dataformat_export_format the export class in use (after any set).

     */

    function export_class_instance($exportclass = null) {

        if (!is_null($exportclass)) {

            $this->started_output = true;

            $this->exportclass = $exportclass;

            $this->exportclass->table = $this;

        } else if (is_null($this->exportclass) && !empty($this->download)) {

            $this->exportclass = new table_dataformat_export_format($this, $this->download);

            if (!$this->exportclass->document_started()) {

                $this->exportclass->start_document($this->filename, $this->sheettitle);

            }

        }

        return $this->exportclass;

    }

    /**

     * Probably don't need to call this directly. Calling is_downloading with a

     * param automatically sets table as downloadable.

     *

     * @param bool $downloadable optional param to set whether data from

     * table is downloadable. If ommitted this function can be used to get

     * current state of table.

     * @return bool whether table data is set to be downloadable.

     */

    function is_downloadable($downloadable = null) {

        if ($downloadable !== null) {

            $this->downloadable = $downloadable;

        }

        return $this->downloadable;

    }

    /**

     * Call with boolean true to store table layout changes in the user_preferences table.

     * Note: user_preferences.value has a maximum length of 1333 characters.

     * Call with no parameter to get current state of table persistence.

     *

     * @param bool $persistent Optional parameter to set table layout persistence.

     * @return bool Whether or not the table layout preferences will persist.

     */

    public function is_persistent($persistent = null) {

        if ($persistent == true) {

            $this->persistent = true;

        }

        return $this->persistent;

    }

    /**

     * Where to show download buttons.

     * @param array $showat array of postions in which to show download buttons.

     * Containing TABLE_P_TOP and/or TABLE_P_BOTTOM

     */

    function show_download_buttons_at($showat) {

        $this->showdownloadbuttonsat = $showat;

    }

    /**

     * Sets the is_sortable variable to the given boolean, sort_default_column to

     * the given string, and the sort_default_order to the given integer.

     * @param bool $bool

     * @param string $defaultcolumn

     * @param int $defaultorder

     * @return void

     */

    function sortable($bool, $defaultcolumn = NULL, $defaultorder = SORT_ASC) {

        $this->is_sortable = $bool;

        $this->sort_default_column = $defaultcolumn;

        $this->sort_default_order  = $defaultorder;

    }

    /**

     * Use text sorting functions for this column (required for text columns with Oracle).

     * Be warned that you cannot use this with column aliases. You can only do this

     * with real columns. See MDL-40481 for an example.

     * @param string column name

     */

    function text_sorting($column) {

        $this->column_textsort[] = $column;

    }

    /**

     * Do not sort using this column

     * @param string column name

     */

    function no_sorting($column) {

        $this->column_nosort[] = $column;

    }

    /**

     * Is the column sortable?

     * @param string column name, null means table

     * @return bool

     */

    function is_sortable($column = null) {

        if (empty($column)) {

            return $this->is_sortable;

        }

        if (!$this->is_sortable) {

            return false;

        }

        return !in_array($column, $this->column_nosort);

    }

    /**

     * Sets the is_collapsible variable to the given boolean.

     * @param bool $bool

     * @return void

     */

    function collapsible($bool) {

        $this->is_collapsible = $bool;

    }

    /**

     * Sets the use_pages variable to the given boolean.

     * @param bool $bool

     * @return void

     */

    function pageable($bool) {

        $this->use_pages = $bool;

    }

    /**

     * Sets the use_initials variable to the given boolean.

     * @param bool $bool

     * @return void

     */

    function initialbars($bool) {

        $this->use_initials = $bool;

    }

    /**

     * Sets the pagesize variable to the given integer, the totalrows variable

     * to the given integer, and the use_pages variable to true.

     * @param int $perpage

     * @param int $total

     * @return void

     */

    function pagesize($perpage, $total) {

        $this->pagesize  = $perpage;

        $this->totalrows = $total;

        $this->use_pages = true;

    }

    /**

     * Assigns each given variable in the array to the corresponding index

     * in the request class variable.

     * @param array $variables

     * @return void

     */

    function set_control_variables($variables) {

        foreach ($variables as $what => $variable) {

            if (isset($this->request[$what])) {

                $this->request[$what] = $variable;

            }

        }

    }

    /**

     * Gives the given $value to the $attribute index of $this->attributes.

     * @param string $attribute

     * @param mixed $value

     * @return void

     */

    function set_attribute($attribute, $value) {

        $this->attributes[$attribute] = $value;

    }

    /**

     * What this method does is set the column so that if the same data appears in

     * consecutive rows, then it is not repeated.

     *

     * For example, in the quiz overview report, the fullname column is set to be suppressed, so

     * that when one student has made multiple attempts, their name is only printed in the row

     * for their first attempt.

     * @param int $column the index of a column.

     */

    function column_suppress($column) {

        if (isset($this->column_suppress[$column])) {

            $this->column_suppress[$column] = true;

        }

    }

    /**

     * Sets the given $column index to the given $classname in $this->column_class.

     * @param int $column

     * @param string $classname

     * @return void

     */

    function column_class($column, $classname) {

        if (isset($this->column_class[$column])) {

            $this->column_class[$column] = ' '.$classname; // This space needed so that classnames don't run together in the HTML

        }

    }

    /**

     * Sets the given $column index and $property index to the given $value in $this->column_style.

     * @param int $column

     * @param string $property

     * @param mixed $value

     * @return void

     */

    function column_style($column, $property, $value) {

        if (isset($this->column_style[$column])) {

            $this->column_style[$column][$property] = $value;

        }

    }

    /**

     * Sets a sticky attribute to a column.

     * @param string $column Column name

     * @param bool $sticky

     */

    public function column_sticky(string $column, bool $sticky = true): void {

        if (isset($this->columnsticky[$column])) {

            $this->columnsticky[$column] = $sticky == true ? ' sticky-column' : '';

        }

    }

    /**

     * Sets the given $attributes to $this->columnsattributes.

     * Column attributes will be added to every cell in the column.

     *

     * @param array[] $attributes e.g. ['c0_firstname' => ['data-foo' => 'bar']]

     */

    public function set_columnsattributes(array $attributes): void {

        $this->columnsattributes = $attributes;

    }

    /**

     * Sets all columns' $propertys to the given $value in $this->column_style.

     * @param int $property

     * @param string $value

     * @return void

     */

    function column_style_all($property, $value) {

        foreach (array_keys($this->columns) as $column) {

            $this->column_style[$column][$property] = $value;

        }

    }

    /**

     * Sets $this->baseurl.

     * @param moodle_url|string $url the url with params needed to call up this page

     */

    function define_baseurl($url) {

        $this->baseurl = new moodle_url($url);

    }

    /**

     * @param array $columns an array of identifying names for columns. If

     * columns are sorted then column names must correspond to a field in sql.

     */

    function define_columns($columns) {

        $this->columns = array();

        $this->column_style = array();

        $this->column_class = array();

        $this->columnsticky = [];

        $this->columnsattributes = [];

        $colnum = 0;

        foreach ($columns as $column) {

            $this->columns[$column]         = $colnum++;

            $this->column_style[$column]    = array();

            $this->column_class[$column]    = '';

            $this->columnsticky[$column]    = '';

            $this->columnsattributes[$column] = [];

            $this->column_suppress[$column] = false;

        }

    }

    /**

     * @param array $headers numerical keyed array of displayed string titles

     * for each column.

     */

    function define_headers($headers) {

        $this->headers = $headers;

    }

    /**

     * Mark a specific column as being a table header using the column name defined in define_columns.

     *

     * Note: Only one column can be a header, and it will be rendered using a th tag.

     *

     * @param   string  $column

     */

    public function define_header_column(string $column) {

        $this->headercolumn = $column;

    }

    /**

     * Defines a help icon for the header

     *

     * Always use this function if you need to create header with sorting and help icon.

     *

     * @param renderable[] $helpicons An array of renderable objects to be used as help icons

     */

    public function define_help_for_headers($helpicons) {

        $this->helpforheaders = $helpicons;

    }

    /**

     * Mark the table preferences to be reset.

     */

    public function mark_table_to_reset(): void {

        $this->resetting = true;

    }

    /**

     * Is the table marked for reset preferences?

     *

     * @return bool True if the table is marked to reset, false otherwise.

     */

    protected function is_resetting_preferences(): bool {

        if ($this->resetting === null) {

            $this->resetting = optional_param($this->request[TABLE_VAR_RESET], false, PARAM_BOOL);

        }

        return $this->resetting;

}

    /**

     * Must be called after table is defined. Use methods above first. Cannot

     * use functions below till after calling this method.

     */

    function setup() {

        if (empty($this->columns) || empty($this->uniqueid)) {

            return false;

        }

        $this->initialise_table_preferences();

        if (empty($this->baseurl)) {

            debugging('You should set baseurl when using flexible_table.');

            global $PAGE;

            $this->baseurl = $PAGE->url;

        }

        if ($this->currpage == null) {

            $this->currpage = optional_param($this->request[TABLE_VAR_PAGE], 0, PARAM_INT);

        }

        $this->setup = true;

        // Always introduce the "flexible" class for the table if not specified

        if (empty($this->attributes)) {

            $this->attributes['class'] = 'flexible table table-striped table-hover';

        } else if (!isset($this->attributes['class'])) {

            $this->attributes['class'] = 'flexible table table-striped table-hover';

        } else if (!in_array('flexible', explode(' ', $this->attributes['class']))) {

            $this->attributes['class'] = trim('flexible table table-striped table-hover ' . $this->attributes['class']);

        }

    }

    /**

     * Get the order by clause from the session or user preferences, for the table with id $uniqueid.

     * @param string $uniqueid the identifier for a table.

     * @return string SQL fragment that can be used in an ORDER BY clause.

     */

    public static function get_sort_for_table($uniqueid) {

        global $SESSION;

        if (isset($SESSION->flextable[$uniqueid])) {

            $prefs = $SESSION->flextable[$uniqueid];

        } else if (!$prefs = json_decode(get_user_preferences("flextable_{$uniqueid}", ''), true)) {

            return '';

        }

        if (empty($prefs['sortby'])) {

            return '';

        }

        if (empty($prefs['textsort'])) {

            $prefs['textsort'] = array();

        }

        return self::construct_order_by($prefs['sortby'], $prefs['textsort']);

    }

    /**

     * Prepare an an order by clause from the list of columns to be sorted.

     * @param array $cols column name => SORT_ASC or SORT_DESC

     * @return string SQL fragment that can be used in an ORDER BY clause.

     */

    public static function construct_order_by($cols, $textsortcols=array()) {

        global $DB;

        $bits = array();

        foreach ($cols as $column => $order) {

            if (in_array($column, $textsortcols)) {

                $column = $DB->sql_order_by_text($column);

            }

            if ($order == SORT_ASC) {

                $bits[] = $DB->sql_order_by_null($column);

            } else {

                $bits[] = $DB->sql_order_by_null($column, SORT_DESC);

            }

        }

        return implode(', ', $bits);

    }

    /**

     * @return string SQL fragment that can be used in an ORDER BY clause.

     */

    public function get_sql_sort() {

        return self::construct_order_by($this->get_sort_columns(), $this->column_textsort);

    }

    /**

     * Whether the current table contains any fullname columns

     *

     * @return bool

     */

    private function contains_fullname_columns(): bool {

        $fullnamecolumns = array_intersect_key($this->columns, array_flip($this->userfullnamecolumns));

        return !empty($fullnamecolumns);

    }

    /**

     * Get the columns to sort by, in the form required by {@link construct_order_by()}.

     * @return array column name => SORT_... constant.

     */

    public function get_sort_columns() {

        if (!$this->setup) {

            throw new coding_exception('Cannot call get_sort_columns until you have called setup.');

        }

        if (empty($this->prefs['sortby'])) {

            return array();

        }

        foreach ($this->prefs['sortby'] as $column => $notused) {

            if (isset($this->columns[$column])) {

                continue; // This column is OK.

            }

            if (in_array($column, \core_user\fields::get_name_fields()) && $this->contains_fullname_columns()) {

                continue; // This column is OK.

            }

            // This column is not OK.

            unset($this->prefs['sortby'][$column]);

        }

        return $this->prefs['sortby'];

    }

    /**

     * @return int the offset for LIMIT clause of SQL

     */

    function get_page_start() {

        if (!$this->use_pages) {

            return '';

        }

        return $this->currpage * $this->pagesize;

    }

    /**

     * @return int the pagesize for LIMIT clause of SQL

     */

    function get_page_size() {

        if (!$this->use_pages) {

            return '';

        }

        return $this->pagesize;

    }

    /**

     * @return array sql to add to where statement.

     */

    function get_sql_where() {

        global $DB;

        $conditions = array();

        $params = array();

        if ($this->contains_fullname_columns()) {

            static $i = 0;

            $i++;

            if (!empty($this->prefs['i_first'])) {

                $conditions[] = $DB->sql_like('firstname', ':ifirstc'.$i, false, false);

                $params['ifirstc'.$i] = $this->prefs['i_first'].'%';

            }

            if (!empty($this->prefs['i_last'])) {

                $conditions[] = $DB->sql_like('lastname', ':ilastc'.$i, false, false);

                $params['ilastc'.$i] = $this->prefs['i_last'].'%';

            }

        }

        return array(implode(" AND ", $conditions), $params);

    }

    /**

     * Add a row of data to the table. This function takes an array or object with

     * column names as keys or property names.

     *

     * It ignores any elements with keys that are not defined as columns. It

     * puts in empty strings into the row when there is no element in the passed

     * array corresponding to a column in the table. It puts the row elements in

     * the proper order (internally row table data is stored by in arrays with

     * a numerical index corresponding to the column number).

     *

     * @param object|array $rowwithkeys array keys or object property names are column names,

     *                                      as defined in call to define_columns.

     * @param string $classname CSS class name to add to this row's tr tag.

     */

    function add_data_keyed($rowwithkeys, $classname = '') {

        $this->add_data($this->get_row_from_keyed($rowwithkeys), $classname);

    }

    /**

     * Add a number of rows to the table at once. And optionally finish output after they have been added.

     *

     * @param (object|array|null)[] $rowstoadd Array of rows to add to table, a null value in array adds a separator row. Or a

     *                                  object or array is added to table. We expect properties for the row array as would be

     *                                  passed to add_data_keyed.

     * @param bool     $finish

     */

    public function format_and_add_array_of_rows($rowstoadd, $finish = true) {

        foreach ($rowstoadd as $row) {

            if (is_null($row)) {

                $this->add_separator();

            } else {

                $this->add_data_keyed($this->format_row($row));

            }

        }

        if ($finish) {

            $this->finish_output(!$this->is_downloading());

        }

    }

    /**

     * Add a seperator line to table.

     */

    function add_separator() {

        if (!$this->setup) {

            return false;

        }

        $this->add_data(NULL);

    }

    /**

     * This method actually directly echoes the row passed to it now or adds it

     * to the download. If this is the first row and start_output has not

     * already been called this method also calls start_output to open the table

     * or send headers for the downloaded.

     * Can be used as before. print_html now calls finish_html to close table.

     *

     * @param array $row a numerically keyed row of data to add to the table.

     * @param string $classname CSS class name to add to this row's tr tag.

     * @return bool success.

     */

    function add_data($row, $classname = '') {

        if (!$this->setup) {

            return false;

        }

        if (!$this->started_output) {

            $this->start_output();

        }

        if ($this->exportclass!==null) {

            if ($row === null) {

                $this->exportclass->add_seperator();

            } else {

                $this->exportclass->add_data($row);

            }

        } else {

            $this->print_row($row, $classname);

        }

        return true;

    }

    /**

     * You should call this to finish outputting the table data after adding

     * data to the table with add_data or add_data_keyed.

     *

     */

    function finish_output($closeexportclassdoc = true) {

        if ($this->exportclass!==null) {

            $this->exportclass->finish_table();

            if ($closeexportclassdoc) {

                $this->exportclass->finish_document();

            }

        } else {

            $this->finish_html();

        }

    }

    /**

     * Hook that can be overridden in child classes to wrap a table in a form

     * for example. Called only when there is data to display and not

     * downloading.

     */

    function wrap_html_start() {

    }

    /**

     * Hook that can be overridden in child classes to wrap a table in a form

     * for example. Called only when there is data to display and not

     * downloading.

     */

    function wrap_html_finish() {

    }

    /**

     * Call appropriate methods on this table class to perform any processing on values before displaying in table.

     * Takes raw data from the database and process it into human readable format, perhaps also adding html linking when

     * displaying table as html, adding a div wrap, etc.

     *

     * See for example col_fullname below which will be called for a column whose name is 'fullname'.

     *

     * @param array|object $row row of data from db used to make one row of the table.

     * @return array one row for the table, added using add_data_keyed method.

     */

    function format_row($row) {

        if (is_array($row)) {

            $row = (object)$row;

        }

        $formattedrow = array();

        foreach (array_keys($this->columns) as $column) {

            $colmethodname = 'col_'.$column;

            if (method_exists($this, $colmethodname)) {

                $formattedcolumn = $this->$colmethodname($row);

            } else {

                $formattedcolumn = $this->other_cols($column, $row);

                if ($formattedcolumn===NULL) {

                    $formattedcolumn = $row->$column;

                }

            }

            $formattedrow[$column] = $formattedcolumn;

        }

        return $formattedrow;

    }

    /**

     * Fullname is treated as a special columname in tablelib and should always

     * be treated the same as the fullname of a user.

     * @uses $this->useridfield if the userid field is not expected to be id

     * then you need to override $this->useridfield to point at the correct

     * field for the user id.

     *

     * @param object $row the data from the db containing all fields from the

     *                    users table necessary to construct the full name of the user in

     *                    current language.

     * @return string contents of cell in column 'fullname', for this row.

     */

    function col_fullname($row) {

        global $COURSE;

        $name = fullname($row, has_capability('moodle/site:viewfullnames', $this->get_context()));

        if ($this->download) {

            return $name;

        }

        $userid = $row->{$this->useridfield};

        if ($COURSE->id == SITEID) {

            $profileurl = new moodle_url('/user/profile.php', array('id' => $userid));

        } else {

            $profileurl = new moodle_url('/user/view.php',

                    array('id' => $userid, 'course' => $COURSE->id));

        }

        return html_writer::link($profileurl, $name);

    }

    /**

     * You can override this method in a child class. See the description of

     * build_table which calls this method.

     */

    function other_cols($column, $row) {

        if (isset($row->$column) && ($column === 'email' || $column === 'idnumber') &&

                (!$this->is_downloading() || $this->export_class_instance()->supports_html())) {

            // Columns email and idnumber may potentially contain malicious characters, escape them by default.

            // This function will not be executed if the child class implements col_email() or col_idnumber().

            return s($row->$column);

        }

        return NULL;

    }

    /**

     * Used from col_* functions when text is to be displayed. Does the

     * right thing - either converts text to html or strips any html tags

     * depending on if we are downloading and what is the download type. Params

     * are the same as format_text function in weblib.php but some default

     * options are changed.

     */

    function format_text($text, $format=FORMAT_MOODLE, $options=NULL, $courseid=NULL) {

        if (!$this->is_downloading()) {

            if (is_null($options)) {

                $options = new stdClass;

            }

            //some sensible defaults

            if (!isset($options->para)) {

                $options->para = false;

            }

            if (!isset($options->newlines)) {

                $options->newlines = false;

            }

            if (!isset($options->filter)) {

                $options->filter = false;

            }

            return format_text($text, $format, $options);

        } else {

            $eci = $this->export_class_instance();

            return $eci->format_text($text, $format, $options, $courseid);

        }

    }

    /**

     * This method is deprecated although the old api is still supported.

     * @deprecated 1.9.2 - Jun 2, 2008

     */

    function print_html() {

        if (!$this->setup) {

            return false;

        }

        $this->finish_html();

    }

    /**

     * This function is not part of the public api.

     * @return string initial of first name we are currently filtering by

     */

    function get_initial_first() {

        if (!$this->use_initials) {

            return NULL;

        }

        return $this->prefs['i_first'];

    }

    /**

     * This function is not part of the public api.

     * @return string initial of last name we are currently filtering by

     */

    function get_initial_last() {

        if (!$this->use_initials) {

            return NULL;

        }

        return $this->prefs['i_last'];

    }

    /**

     * Helper function, used by {@link print_initials_bar()} to output one initial bar.

     * @param array $alpha of letters in the alphabet.

     * @param string $current the currently selected letter.

     * @param string $class class name to add to this initial bar.

     * @param string $title the name to put in front of this initial bar.

     * @param string $urlvar URL parameter name for this initial.

     *

     * @deprecated since Moodle 3.3

     */

    protected function print_one_initials_bar($alpha, $current, $class, $title, $urlvar) {

        debugging('Method print_one_initials_bar() is no longer used and has been deprecated, ' .

            'to print initials bar call print_initials_bar()', DEBUG_DEVELOPER);

        echo html_writer::start_tag('div', array('class' => 'initialbar ' . $class)) .

            $title . ' : ';

        if ($current) {

            echo html_writer::link($this->baseurl->out(false, array($urlvar => '')), get_string('all'));

        } else {

            echo html_writer::tag('strong', get_string('all'));