mirror of
https://github.com/FH-Complete/FHC-Core.git
synced 2026-06-01 12:19:28 +00:00
SimonGschnell
465 lines
18 KiB
PHP
465 lines
18 KiB
PHP
<?php
|
|
|
|
/**
|
|
* Copyright (C) 2023 fhcomplete.org
|
|
*
|
|
* This program 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.
|
|
*
|
|
* This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/**
|
|
* To display a table that shows data retriev by a SQL statement
|
|
*/
|
|
class TableWidget extends Widget
|
|
{
|
|
// Paths of the views
|
|
const WIDGET_URL_TABLE = 'widgets/table/table';
|
|
const WIDGET_URL_DATASET_TABLESORTER = 'widgets/table/tableDataset';
|
|
const WIDGET_URL_DATASET_PIVOTUI = 'widgets/table/pivotUIDataset';
|
|
const WIDGET_URL_DATASET_TABULATOR = 'widgets/table/tabulatorDataset';
|
|
|
|
// Default formats
|
|
const DEFAULT_DATE_FORMAT = 'd.m.Y H:i:s';
|
|
const DEFAULT_MARK_ROW_CLASS = 'text-danger';
|
|
|
|
// Required permissions to use this TableWidget
|
|
private $_requiredPermissions;
|
|
|
|
// optional bootstrap version can be set to use different bootstrap classes
|
|
private $_bootstrapVersion=3;
|
|
|
|
// SQL statement
|
|
private $_query;
|
|
|
|
// Additional columns to add to the dataset or aliases to be used to rename columns of the dataset
|
|
private $_additionalColumns;
|
|
private $_columnsAliases;
|
|
|
|
// To format or mark rows of the dataset
|
|
private $_formatRow;
|
|
private $_markRow;
|
|
|
|
// To have a column in the GUI with checkboxes to select rows in the table
|
|
private $_checkboxes;
|
|
|
|
private $_datasetRepresentation; // dataset representation (ex: tablesorter, pivotUI, ...)
|
|
private $_datasetRepresentationOptions; // dataset representation options for tablesorter, pivotUI, ...
|
|
private $_datasetRepFieldsDefs; // dataset representation attributes for each record field
|
|
|
|
private $_reloadDataset; // Force Reload of Dataset
|
|
|
|
private $_sessionTimeout; // session expiring time
|
|
|
|
private $_encryptedColumns; // contains info about encrypted columns
|
|
|
|
private static $_TableWidgetInstance; // static property that contains the instance of itself
|
|
|
|
/**
|
|
* Initialize the TableWidget and starts the execution of the logic
|
|
*/
|
|
public function __construct($name, $args = array())
|
|
{
|
|
parent::__construct($name, $args); // calls the parent's constructor
|
|
|
|
self::$_TableWidgetInstance = $this; // set static property $_TableWidgetInstance with this instance
|
|
|
|
$this->load->library('TableWidgetLib'); // Loads the TableWidgetLib that contains all the used logic
|
|
|
|
$this->_initTableWidget($args); // checks parameters and initialize properties
|
|
|
|
$this->tablewidgetlib->setTableUniqueIdByParams($args);
|
|
|
|
// Let's start if it's allowed
|
|
// NOTE: If it is NOT allowed then no data are loaded
|
|
if ($this->tablewidgetlib->isAllowed($this->_requiredPermissions))
|
|
{
|
|
$this->_startTableWidget($args[TableWidgetLib::TABLE_UNIQUE_ID]);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------
|
|
// Public methods
|
|
|
|
/**
|
|
* Called when echoing the table widget call
|
|
*/
|
|
public function display($widgetData)
|
|
{
|
|
|
|
$this->view(self::WIDGET_URL_TABLE, array(
|
|
'tableUniqueId' => $widgetData[TableWidgetLib::TABLE_UNIQUE_ID],
|
|
)); // GUI starts here
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------
|
|
// Public static methods used to load views and to access statically to some properies of the TableWidget
|
|
|
|
/**
|
|
* Loads the view related to the dataset, here is decided how to represent the dataset (ex: tablesorter, pivotUI, ...)
|
|
*/
|
|
public static function loadViewDataset()
|
|
{
|
|
if (self::$_TableWidgetInstance->_datasetRepresentation == TableWidgetLib::DATASET_REP_TABLESORTER)
|
|
{
|
|
self::_loadView(self::WIDGET_URL_DATASET_TABLESORTER);
|
|
}
|
|
|
|
if (self::$_TableWidgetInstance->_datasetRepresentation == TableWidgetLib::DATASET_REP_PIVOTUI)
|
|
{
|
|
self::_loadView(self::WIDGET_URL_DATASET_PIVOTUI);
|
|
}
|
|
|
|
if (self::$_TableWidgetInstance->_datasetRepresentation == TableWidgetLib::DATASET_REP_TABULATOR)
|
|
{
|
|
self::_loadView(self::WIDGET_URL_DATASET_TABULATOR);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------
|
|
// Private methods
|
|
|
|
/**
|
|
* Checks parameters and initialize all the properties of this TableWidget
|
|
*/
|
|
private function _initTableWidget($args)
|
|
{
|
|
$this->_checkParameters($args);
|
|
|
|
// If here then everything is ok
|
|
|
|
// Initialize class properties
|
|
$this->_requiredPermissions = null;
|
|
$this->_bootstrapVersion = null;
|
|
$this->_reloadDataset = true; // by default the dataset is NOT cached in session
|
|
$this->_query = null;
|
|
$this->_additionalColumns = null;
|
|
$this->_columnsAliases = null;
|
|
$this->_formatRow = null;
|
|
$this->_markRow = null;
|
|
$this->_checkboxes = null;
|
|
$this->_datasetRepresentation = null;
|
|
$this->_datasetRepresentationOptions = null;
|
|
$this->_datasetRepFieldsDefs = null;
|
|
$this->_sessionTimeout = TableWidgetLib::SESSION_DEFAULT_TIMEOUT;
|
|
$this->_encryptedColumns = null;
|
|
|
|
// Retrieved the required permissions parameter if present
|
|
if (isset($args[TableWidgetLib::REQUIRED_PERMISSIONS]))
|
|
{
|
|
$this->_requiredPermissions = $args[TableWidgetLib::REQUIRED_PERMISSIONS];
|
|
}
|
|
|
|
// Retrieved the optional tableWindget Bootstrap version
|
|
if (isset($args[TableWidgetLib::TABLE_BOOTSTRAP_VERSION]) && !isEmptyString($args[TableWidgetLib::TABLE_BOOTSTRAP_VERSION]))
|
|
{
|
|
$this->_bootstrapVersion = $args[TableWidgetLib::TABLE_BOOTSTRAP_VERSION];
|
|
}
|
|
|
|
// How to retrieve data for the table: SQL statement or a result from DB
|
|
if (isset($args[TableWidgetLib::QUERY]))
|
|
{
|
|
$this->_query = $args[TableWidgetLib::QUERY];
|
|
}
|
|
|
|
if (isset($args[TableWidgetLib::DATASET_RELOAD]))
|
|
{
|
|
$this->_reloadDataset = $args[TableWidgetLib::DATASET_RELOAD];
|
|
}
|
|
|
|
// Parameter is used to add extra columns to the dataset
|
|
if (isset($args[TableWidgetLib::ADDITIONAL_COLUMNS])
|
|
&& is_array($args[TableWidgetLib::ADDITIONAL_COLUMNS])
|
|
&& count($args[TableWidgetLib::ADDITIONAL_COLUMNS]) > 0)
|
|
{
|
|
$this->_additionalColumns = $args[TableWidgetLib::ADDITIONAL_COLUMNS];
|
|
}
|
|
|
|
// Parameter is used to add use aliases for the columns fo the dataset
|
|
if (isset($args[TableWidgetLib::COLUMNS_ALIASES])
|
|
&& is_array($args[TableWidgetLib::COLUMNS_ALIASES])
|
|
&& count($args[TableWidgetLib::COLUMNS_ALIASES]) > 0)
|
|
{
|
|
$this->_columnsAliases = $args[TableWidgetLib::COLUMNS_ALIASES];
|
|
}
|
|
|
|
// Parameter that contains a function to format the rows of the dataset
|
|
if (isset($args[TableWidgetLib::FORMAT_ROW]) && is_callable($args[TableWidgetLib::FORMAT_ROW]))
|
|
{
|
|
$this->_formatRow = $args[TableWidgetLib::FORMAT_ROW];
|
|
}
|
|
|
|
// Parameter that contains a function to mark in the GUI the rows of the dataset
|
|
if (isset($args[TableWidgetLib::MARK_ROW]) && is_callable($args[TableWidgetLib::MARK_ROW]))
|
|
{
|
|
$this->_markRow = $args[TableWidgetLib::MARK_ROW];
|
|
}
|
|
|
|
// Parameter used to specify the column of the dataset that will be used
|
|
// as id of the checkboxes column in the GUI
|
|
if (isset($args[TableWidgetLib::CHECKBOXES]))
|
|
{
|
|
$this->_checkboxes = $args[TableWidgetLib::CHECKBOXES];
|
|
}
|
|
|
|
// To specify how to represent the dataset (ex: tablesorter, pivotUI, ...)
|
|
if (isset($args[TableWidgetLib::DATASET_REPRESENTATION])
|
|
&& ($args[TableWidgetLib::DATASET_REPRESENTATION] == TableWidgetLib::DATASET_REP_TABLESORTER
|
|
|| $args[TableWidgetLib::DATASET_REPRESENTATION] == TableWidgetLib::DATASET_REP_PIVOTUI
|
|
|| $args[TableWidgetLib::DATASET_REPRESENTATION] == TableWidgetLib::DATASET_REP_TABULATOR))
|
|
{
|
|
$this->_datasetRepresentation = $args[TableWidgetLib::DATASET_REPRESENTATION];
|
|
}
|
|
|
|
// To specify options for the dataset representation (ex: tablesorter, pivotUI, ...)
|
|
if (isset($args[TableWidgetLib::DATASET_REP_OPTIONS]) && !isEmptyString($args[TableWidgetLib::DATASET_REP_OPTIONS]))
|
|
{
|
|
$this->_datasetRepresentationOptions = $args[TableWidgetLib::DATASET_REP_OPTIONS];
|
|
}
|
|
|
|
// To specify how to represent each record field
|
|
if (isset($args[TableWidgetLib::DATASET_REP_FIELDS_DEFS]) && !isEmptyString($args[TableWidgetLib::DATASET_REP_FIELDS_DEFS]))
|
|
{
|
|
$this->_datasetRepFieldsDefs = $args[TableWidgetLib::DATASET_REP_FIELDS_DEFS];
|
|
}
|
|
|
|
// To specify the expiring session time
|
|
if (isset($args[TableWidgetLib::SESSION_TIMEOUT]) && is_numeric($args[TableWidgetLib::SESSION_TIMEOUT]))
|
|
{
|
|
$this->_sessionTimeout = $args[TableWidgetLib::SESSION_TIMEOUT];
|
|
}
|
|
|
|
// Parameter is used to define the ecrypted columns
|
|
if (isset($args[TableWidgetLib::ENCRYPTED_COLUMNS])
|
|
&& is_array($args[TableWidgetLib::ENCRYPTED_COLUMNS])
|
|
&& count($args[TableWidgetLib::ENCRYPTED_COLUMNS]) > 0)
|
|
{
|
|
$this->_encryptedColumns = $args[TableWidgetLib::ENCRYPTED_COLUMNS];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks the required parameters used to call this TableWidget
|
|
*/
|
|
private function _checkParameters($args)
|
|
{
|
|
// If no options are given to this widget...
|
|
if (!is_array($args) || (is_array($args) && count($args) == 0))
|
|
{
|
|
show_error('Second parameter of the widget call must be a NOT empty associative array');
|
|
}
|
|
else // ...otherwise
|
|
{
|
|
// The unique id parameter is mandatory
|
|
if (!isset($args[TableWidgetLib::TABLE_UNIQUE_ID]))
|
|
{
|
|
show_error('The parameter "'.TableWidgetLib::TABLE_UNIQUE_ID.'" must be specified');
|
|
}
|
|
|
|
// The query parameter is mandatory
|
|
if (!isset($args[TableWidgetLib::QUERY]))
|
|
{
|
|
show_error('The parameter "'.TableWidgetLib::QUERY.'" must be specified');
|
|
}
|
|
|
|
// The dataset representation parameter is mandatory
|
|
if (!isset($args[TableWidgetLib::DATASET_REPRESENTATION]))
|
|
{
|
|
show_error('The parameter "'.TableWidgetLib::DATASET_REPRESENTATION.'" must be specified');
|
|
}
|
|
|
|
// Checks if the dataset representation parameter is valid
|
|
if (isset($args[TableWidgetLib::DATASET_REPRESENTATION])
|
|
&& $args[TableWidgetLib::DATASET_REPRESENTATION] != TableWidgetLib::DATASET_REP_TABLESORTER
|
|
&& $args[TableWidgetLib::DATASET_REPRESENTATION] != TableWidgetLib::DATASET_REP_PIVOTUI
|
|
&& $args[TableWidgetLib::DATASET_REPRESENTATION] != TableWidgetLib::DATASET_REP_TABULATOR)
|
|
{
|
|
show_error(
|
|
'The parameter "'.TableWidgetLib::DATASET_REPRESENTATION.
|
|
'" must be IN ("'
|
|
.TableWidgetLib::DATASET_REP_TABLESORTER.'", "'
|
|
.TableWidgetLib::DATASET_REP_PIVOTUI.'", "'
|
|
.TableWidgetLib::DATASET_REP_TABULATOR.'")'
|
|
);
|
|
}
|
|
|
|
// If given the session timeout parameter must be a number
|
|
if (isset($args[TableWidgetLib::SESSION_TIMEOUT]) && !is_numeric($args[TableWidgetLib::SESSION_TIMEOUT]))
|
|
{
|
|
show_error('The parameter "'.TableWidgetLib::SESSION_TIMEOUT.'" must be a number');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Contains all the logic used to load all the data needed to the TableWidget
|
|
*/
|
|
private function _startTableWidget($tableUniqueId)
|
|
{
|
|
// Looks for expired table widgets in session and drops them
|
|
$this->tablewidgetlib->dropExpiredTableWidgets();
|
|
|
|
// Read the all session for this table widget
|
|
$session = $this->tablewidgetlib->getSession();
|
|
|
|
// If session is NOT empty -> a table was already loaded
|
|
if ($session != null)
|
|
{
|
|
// Get SESSION_DATASET_RELOAD from the session
|
|
$sessionReloadDataset = $this->tablewidgetlib->getSessionElement(TableWidgetLib::SESSION_DATASET_RELOAD);
|
|
|
|
// if Filter changed or reload is forced by parameter then reload the Dataset
|
|
if ($this->_reloadDataset === true || $sessionReloadDataset === true)
|
|
{
|
|
// Set as false to stop changing the dataset
|
|
$this->tablewidgetlib->setSessionElement(TableWidgetLib::SESSION_DATASET_RELOAD, false);
|
|
|
|
// Generate dataset query using tables from the session
|
|
$datasetQuery = $this->tablewidgetlib->generateDatasetQuery($this->_query);
|
|
|
|
// Then retrieve dataset from DB
|
|
$dataset = $this->tablewidgetlib->getDataset($datasetQuery, $this->_encryptedColumns);
|
|
|
|
// Save changes into session if data are valid
|
|
if (!isError($dataset))
|
|
{
|
|
$this->_formatDataset($dataset); // marks rows using markRow and format rowns using formatRow
|
|
|
|
// Set the new dataset and its attributes in the session
|
|
$this->tablewidgetlib->setSessionElement(TableWidgetLib::SESSION_METADATA, $this->tablewidgetlib->getExecutedQueryMetaData());
|
|
$this->tablewidgetlib->setSessionElement(TableWidgetLib::SESSION_ROW_NUMBER, count($dataset->retval));
|
|
$this->tablewidgetlib->setSessionElement(TableWidgetLib::SESSION_DATASET, $dataset->retval);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the session is empty -> first time that this table is loaded
|
|
if ($session == null)
|
|
{
|
|
// Generate dataset query
|
|
$datasetQuery = $this->tablewidgetlib->generateDatasetQuery($this->_query);
|
|
|
|
// Then retrieve dataset from DB
|
|
$dataset = $this->tablewidgetlib->getDataset($datasetQuery, $this->_encryptedColumns);
|
|
|
|
// Save changes into session if data are valid
|
|
if (!isError($dataset))
|
|
{
|
|
$this->_formatDataset($dataset); // marks rows using markRow and format rowns using formatRow
|
|
|
|
// Stores an array that contains all the data useful for
|
|
$this->tablewidgetlib->setSession(
|
|
array(
|
|
TableWidgetLib::TABLE_UNIQUE_ID => $tableUniqueId, // table unique id
|
|
TableWidgetLib::TABLE_BOOTSTRAP_VERSION => $this->_bootstrapVersion, // bootstrap version for tableWidget
|
|
TableWidgetLib::SESSION_FIELDS => $this->tablewidgetlib->getExecutedQueryListFields(), // all the fields of the dataset
|
|
TableWidgetLib::SESSION_COLUMNS_ALIASES => $this->_columnsAliases, // all the fields aliases
|
|
TableWidgetLib::SESSION_ADDITIONAL_COLUMNS => $this->_additionalColumns, // additional columns
|
|
TableWidgetLib::SESSION_ENCRYPTED_COLUMNS => $this->_encryptedColumns, // encrypted columns
|
|
TableWidgetLib::SESSION_CHECKBOXES => $this->_checkboxes, // the name of the field used to build the checkboxes column
|
|
TableWidgetLib::SESSION_METADATA => $this->tablewidgetlib->getExecutedQueryMetaData(), // the metadata of the dataset
|
|
TableWidgetLib::SESSION_ROW_NUMBER => count($dataset->retval), // the number of loaded rows by this table
|
|
TableWidgetLib::SESSION_DATASET => $dataset->retval, // the entire dataset
|
|
TableWidgetLib::SESSION_DATASET_RELOAD => false, // if the dataset must be reloaded, not needed the first time
|
|
TableWidgetLib::SESSION_DATASET_REPRESENTATION => $this->_datasetRepresentation, // the choosen dataset representation
|
|
TableWidgetLib::SESSION_DATASET_REP_OPTIONS => $this->_datasetRepresentationOptions, // the choosen dataset representation options
|
|
TableWidgetLib::SESSION_DATASET_REP_FIELDS_DEFS => $this->_datasetRepFieldsDefs // the choosen dataset representation record fields definition
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
// NOTE: must the latest operation to be performed in the session to be shure that is always present
|
|
// To be always stored in the session, otherwise is not possible to load data from Filters controller
|
|
$this->tablewidgetlib->setSessionElement(TableWidgetLib::REQUIRED_PERMISSIONS, $this->_requiredPermissions);
|
|
// Renew or set the session expiring time
|
|
$this->tablewidgetlib->setSessionElement(TableWidgetLib::SESSION_TIMEOUT, strtotime('+'.$this->_sessionTimeout.' minutes', time()));
|
|
}
|
|
|
|
/**
|
|
* Calls the method _markRow and _formatRow to marks rows using markRow and format rowns using formatRow
|
|
* NOTE: this method operates directly on the retrieved dataset: parameter passed by reference
|
|
*/
|
|
private function _formatDataset(&$rawDataset)
|
|
{
|
|
if (hasData($rawDataset) && is_array($rawDataset->retval))
|
|
{
|
|
// For each row of the data set
|
|
for ($rowCounter = 0; $rowCounter < count($rawDataset->retval); $rowCounter++)
|
|
{
|
|
// Calls the methods to mark and to format a row
|
|
// NOTE: keep this order! the markRow function given as parameter is supposing to work
|
|
// on a raw dataset, NOT on a formatted one
|
|
$rawDataset->retval[$rowCounter]->MARK_ROW_CLASS = $this->_markRow($rawDataset->retval[$rowCounter]);
|
|
$this->_formatRow($rawDataset->retval[$rowCounter]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Formats the columns of all the rows of the entire dataset
|
|
* - converts booleans into strings "true" and "false"
|
|
* - format dates using the format string defined in DEFAULT_DATE_FORMAT
|
|
* Calls the parameter formatRow if it was given and if it is a valid funtion
|
|
* NOTE: this method operates directly on the retrieved dataset: parameter passed by reference
|
|
*/
|
|
private function _formatRow(&$rawDatasetRow)
|
|
{
|
|
// For each column of the row
|
|
foreach ($rawDatasetRow as $columnName => $columnValue)
|
|
{
|
|
// Basic conversions
|
|
if (is_bool($columnValue))
|
|
{
|
|
$rawDatasetRow->{$columnName} = ($columnValue === true ? 'true' : 'false');
|
|
}
|
|
elseif (DateTime::createFromFormat('Y-m-d H:i:s', $columnValue) !== false)
|
|
{
|
|
$rawDatasetRow->{$columnName} = date(self::DEFAULT_DATE_FORMAT, strtotime($columnValue));
|
|
}
|
|
}
|
|
|
|
// If a valid function call the given formatRow
|
|
if ($this->_formatRow != null && is_callable($this->_formatRow))
|
|
{
|
|
$formatRowFunction = $this->_formatRow;
|
|
$rawDatasetRow = $formatRowFunction($rawDatasetRow);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a string that contains a class name used to mark rows in the dataset table
|
|
* Calls the parameter markRow if it was given and if it is a valid funtion
|
|
*/
|
|
private function _markRow($rawDatasetRow)
|
|
{
|
|
// If a valid function call the given markRow
|
|
if ($this->_markRow != null && is_callable($this->_markRow))
|
|
{
|
|
$markRowFunction = $this->_markRow;
|
|
$class = $markRowFunction($rawDatasetRow);
|
|
}
|
|
|
|
return !isset($class) ? '' : $class;
|
|
}
|
|
|
|
/**
|
|
* Loads a view using the given viewName and eventually other parameters
|
|
*/
|
|
private static function _loadView($viewName, $parameters = null)
|
|
{
|
|
$ci =& get_instance();
|
|
$ci->load->view($viewName, $parameters);
|
|
}
|
|
}
|
|
|