-------------------------------------------------------------------------------
$Id$
-----------------------------------------------------------------------------*/
require_once 'DB.php';
require_once 'MECON/DB/Pager.php';
require_once 'MECON/HTML/Error.php';
require_once 'MECON/HTML/Link.php';
require_once 'MECON/HTML/Tabla.php';
/**
* Libreria para le manejo de las tablas de los sistemas de intranet.
*
*/
class MECON_HTML_TablaDB extends MECON_HTML_Tabla {
/**
* Descripción de los elementos listados.
* Se utiliza en mensajes del paginador y otros mensajes.
*/
var $_desc = 'resultados';
/**
* Datos a agregar delante de cada fila que se agregue desde una base de datos.
* Cada elemento del array es a su vez un array cuyo primer elemento es el
* formato del texto a agregar (tipo printf()) y el segundo es un array con los
* campos de la DB a utilizar para ese formato en una fila dada.
* Cuando se utiliza una callback para "dibujar" el campo, el campo puede
* ser un array de campos de la base que se quiere pasar a la callback.
*/
var $_prependRowsData = array();
/**
* Datos a agregar al final de cada fila que se agregue desde una base de datos.
* El formato es el mismo que el de _prependRowsData.
*/
var $_appendRowsData = array();
/**
* Prefijo a usar para las variables GET que genera la tabla.
*/
var $_getVarPrefix = '_';
/**
* Constructor.
* Puede recibir como parametro un string con los atributos que se
* quieren dar a la tabla en cuestion. Estos atributos estan
* seteados por default segun el archivo de configuracion.
* Ademas puede recibir la indicacion de algun estilo en particular.
*
* @param string $desc Descripción de los elementos listados.
* @param mixed $attrs Atributos diferentes a los estandares para la tabla
* @param string $estilo Tipo de tabla
*
* @access public
*/
function MECON_HTML_TablaDB($desc = null, $attrs = null, $estilo = 'comun') {
if ($desc) {
$this->_desc = $desc;
}
parent::MECON_HTML_Tabla($attrs, $estilo);
}
/**
* Establece el prefijo usado para las variables de GET que genera la tabla.
*/
function setGetVarPrefix($prefix) {
$this->_getVarPrefix = $prefix;
}
/**
* Obtiene el prefijo usado para las variables de GET que genera la tabla.
*/
function getGetVarPrefix() {
return $this->_getVarPrefix;
}
/**
* Agrega un páginador a la tabla, basado en un resultado de una base de datos.
* Ejemplo:
* @code
* $tabla = new MECON_HTML_TablaDB('personas', array('width' => '100%'));
* $result = $db->query('SELECT nombre, apellido FROM tabla');
* if (DB::isError($result)) {
* trigger_error('Error', E_USER_ERROR);
* }
* // Agrega el paginador por defecto y lo guarda para mostrar solo los
* // resultados paginados después.
* $pager = $tabla->addPager($result);
* // Agrega cabecera con los nombres de las columnas.
* $tabla->addRow(array('Nombre', 'Apellido'), 'cabecera');
* // Agrega los resultados paginados de la DB.
* $tabla->addRows($pager, array('nombre', 'apellido'));
* $tabla->display();
* @endcode
*
* @param DB_Result $result Resultado de una consulta de base de datos.
* @param mixed $tipo Tipo de link(s) a agregar. Puede ser:
*
*
'anterior'
*
'siguiente'
*
'paginas'
*
'total'
*
'info'
*
* Puede pasarse uno solo como un string o varios como un
* array. Si se pasa 'todo', se incluyen todos.
* Si se pasa null, se incluyen 'anterior',
* 'siguiente' y 'paginas'.
* @param mixed $link Dirección a la que apuntan los links generados. Puede
* ser un MECON_HTML_Link (para poder pasar variables por
* GET) o un string.
* @param int $limit Parámetro usado para crear el MECON_DB_Pager.
* @param int $maxpages Parámetro usado para crear el MECON_DB_Pager.
* @param string $getvar Nombre de la variable GET a usar para indicar el número
* de página actual (se le pone el \ref setGetPrefix prefijo)
*
* @return MECON_DB_Pager Pager que se puede usar para realizar los fetch de
* los resultados de la página actual.
*
* @see MECON_DB_Pager, addRows().
*/
function addPager($result, $tipo = null, $link = null, $limit = 10, $maxpages = 21, $getvar = 'from') {
// Creo el pager con el resultado.
$pager = new MECON_DB_Pager($result, @$_GET[$this->_getVarPrefix.$getvar], $limit, $maxpages);
// Obtengo un link válido.
if (!$link) {
$link = @$_SERVER['PHP_SELF'];
}
if (is_string($link)) {
$link = new MECON_HTML_Link($link, '');
}
// Si es el tipo por defecto pone paginador nada más.
if (!$tipo) {
$tipo = array('anterior', 'paginas', 'siguiente');
}
// Convierte tipo a array.
if (!is_array($tipo)) {
$tipo = array($tipo);
}
// Si se quiere mostrar todas las decoraciones del paginador.
if (in_array('todo', $tipo)) {
$tipo = array('anterior', 'paginas', 'siguiente', 'total', 'info');
}
// Me fijo si tiene cada uno de los elementos y los agrego.
if (in_array('anterior', $tipo) and $pager->numRows() and $pager->currentpage != 1) {
$link->setGetVar($this->_getVarPrefix.$getvar, $pager->prev);
$this->addLink('anterior', $link);
}
if (in_array('siguiente', $tipo) and $pager->numRows() and $pager->currentpage != $pager->numpages) {
$link->setGetVar($this->_getVarPrefix.$getvar, $pager->next);
$this->addLink('siguiente', $link);
}
if (in_array('paginas', $tipo) and $pager->numRows() and $pager->numpages > 1) {
$from = @$_GET[$this->_getVarPrefix.$getvar];
$pags = '';
$lnk = $link->getContents();
foreach ($pager->pages as $page => $start_row) {
if ($start_row == $from) {
$pags .= $page;
} else {
$link->setGetVar($this->_getVarPrefix.$getvar, $start_row);
$link->setContents($page);
$pags .= $link->toHtml();
}
if ($page != $pager->lastpage) {
$pags .= ' | ';
}
}
$link->setContents($lnk);
$this->updatePie($pags, 'centro');
}
if (in_array('total', $tipo) and $pager->numRows()) {
$this->updateCabecera("Se encontraron {$pager->numrows} {$this->_desc}.", 'izquierda');
}
if (in_array('info', $tipo) and $pager->numRows()) {
$this->updateCabecera("'Página {$pager->currentpage} de {$pager->numpages} - "
. "{$pager->limit} {$this->_desc} por página.", 'derecha');
}
return $pager;
}
/**
* Agrega filas desde el resultado de una consulta a una base de datos.
* Si no hay resultados, muestra un mensaje. Dependiendo de si es se pasa
* un objeto a usar o no, llama a addRowsObject() o addRowsResult()
* respectivamente.
*
* @param DB_Result $result Resultados de una consulta.
* @param array $campos Propiedades del objeto a mostrar.
* @param mixed $obj Objeto a usar. Puede ser un objeto instanciado o un
* string con el nombre de la clase.
*
* @see addRowsData(), addRowsIcon(), ejemplo en addPager().
*/
function addRows($result, $campos, $obj = null) {
if ($result->numRows()) {
if ($obj) {
$this->addRowsObject($result, $campos, $obj);
} else {
$this->addRowsResult($result, $campos, $obj);
}
} else {
$id = $this->addRow(array(
new MECON_HTML_Error("No se encontraron {$this->_desc}.")));
$this->updateCellAttributes($id, 0,
array('colspan' => count($campos)
+ count($this->_prependRowsData)
+ count($this->_appendRowsData)));
}
}
/**
* Agrega filas usando un resultado.
*
* @param DB_Result $result Resultados de una consulta.
* @param array $campos Campos de la base de datos a mostrar.
*/
function addRowsResult($result, $campos) {
while ($row = $result->fetchRow(DB_FETCHMODE_ASSOC)) {
$columnas = array();
foreach ($this->_prependRowsData as $data) {
$columnas[] = $this->_buildCustomColumn($data, $row);
}
foreach ($campos as $campo) {
$columnas[] = $row[$campo];
}
foreach ($this->_appendRowsData as $data) {
$columnas[] = $this->_buildCustomColumn($data, $row);
}
$this->addRow($columnas);
}
}
/**
* Agrega filas usando un objeto.
* El objeto debe tener un método llamado cargar que acepte como primer (y
* único obligatorio) parámetro un DB_Result para cargar sus datos desde una
* base de datos.
*
* @param DB_Result $result Resultados de una consulta.
* @param array $campos Propiedades del objeto a mostrar.
* @param mixed $obj Objeto a usar. Puede ser un objeto instanciado o un
* string con el nombre de la clase.
*
* @see La interfaz MECON_DBO que tiene el método MECON_DBO::cargar().
*/
function addRowsObject($result, $campos, $obj) {
if (is_string($obj)) {
$obj = new $obj;
}
if (!method_exists($obj, 'cargar')) {
$this->raiseError('La clase ' . get_class($obj) . ' no tiene un metodo cargar().');
}
while ($obj->cargar($result)) {
foreach ($this->_prependRowsData as $data) {
$columnas[] = $this->_buildCustomColumn($data, $row);
}
foreach ($campos as $campo) {
$columnas[] = $obj->$campo;
}
foreach ($this->_appendRowsData as $data) {
$columnas[] = $this->_buildCustomColumn($data, $row);
}
$this->addRow($columnas);
}
}
/**
* Agrega una columna arbitraria a la tabla basado en valores de una fila.
* Ejemplo:
* @code
* $tabla = new MECON_HTML_TablaDB('personas', array('width' => '100%'));
* $result = $db->query('SELECT nombre, apellido, activo FROM tabla');
* if (DB::isError($result)) {
* trigger_error('Error', E_USER_ERROR);
* }
* $tabla->addRow(
* array('Col1', 'Nombre', 'Apellido', 'Activo', 'PopUp1', 'PopUp2'),
* 'cabecera');
* // Agrega una columna con una leyenda 'El nombre es: {nombre}' al principio.
* $tabla->addRowsData('Me llamo %s.', 'nombre', 'prepend');
* // Agrega una columna al final con checkbox para seleccionar filas. El
* // segundo elemento será procesado por la callback checked_callback().
* $tabla->addRowsData('',
* array('nombre', array('activo', 'checked_callback')));
* // Agrega el nombre con un link a un popup (sin javascript).
* $tabla->addRowsData(
* new MECON_HTML_Link('popup.php', '%s', array('nombre' => null),
* array('target' => '_blank')),
* 'nombre',
* 'prepend');
* // Agrega el nombre con un link a un popup (con javascript).
* $tabla->addRowsData('%s',
* array('nombre', 'nombre', 'apellido'));
* // Agrega resultados de la tabla.
* $tabla->addRows($result, array('nombre', 'apellido'));
*
*
* //Ejemplo utilizando una funcion callback con varios parametros obtenidos
* //de la DB.
* $tabla->addRowsData (
* 'Mi nombre es: %s, por lo tanto %s', //Formato de la columna a agregar.
* array( //Array de campos a incluir en el formato
* 'nombre', //El dato de este campo reemplazara el primer %s
* //El resultado de la llamada a la funcion nombre_callback que tomo
* //como paramteros los campos de la db que estan dentro del array
* //reemplazara al segundo %s
* array(array('nombre', 'apellido'), 'nombre_callback')
* )
* );
*
* $tabla->display();
*
* // Funcion callback para darle formato al campo 'activo'.
* // En este caso devuelve 'checked' para indicar que el checkbox está
* // activado si activo es true.
* function checked_callback($activo) {
* return $activo ? 'checked' : '';
* }
*
* //Funcion callback que acepta mas de un parametro en un array
* function nombre_callback($parametros) {
* if ($parametros['nombre'] == 'Juan Carlos' &&
* $parametros['apellido'] == 'Gomez') {
* return 'soy Charly';
* }
* else {
* return 'no soy Charly';
* }
* }
*
* @endcode
*
* @param mixed $format Si es un string, especifica el formato a usar al
* estilo de sprintf. Si es un MECON_HTML_Link, se
* traduce cada variable por GET que empiece con el
* \ref getGetVarPrefix "prefijo" y cuyo valor sea null
* al campo correspondiente de la DB:
* @code $tabla->addRowsData(new MECON_HTML_Link('abm.php', 'Ver %s',
* array($tabla->getGetVarPrefix().'id' => null), 'nombre'); @endcode
* Si el valor en vez de ser null es un string, se
* fija si existe una función con ese nombre para llamar
* con el campo de la DB como argumento para
* formatearlo:
* @code $tabla->addRowsData(new MECON_HTML_Link('print.php', 'Mostrar',
* array($tabla->getGetVarPrefix().'campo1' => 'callback_campo1'));
* function callback_campo1($campo1) {
* return 'El campo1 es '.strtoupper($campo3);
* } @endcode
* Si no existe la función, se toma el string como
* formato para sprintf para darle formato:
* @code $tabla->addRowsData(new MECON_HTML_Link('print.php', 'Ver',
* array($tabla->getGetVarPrefix().'campo1' => 'campo1: %s')); @endcode
* @param mixed $campos Campos de la DB a usar como argumentos del sprintf.
* Puede ser un string para pasar un solo campo sin
* formato:
* @code $tabla->addRowsData('%s', 'campo1'); @endcode
* Si es un array, cada elemento es un campo
* que puede ser un string representando el nombre de
* un campo a usar:
* @code $tabla->addRowsData('%s',
* array('campo1', 'campo2'); @endcode
* o un array cuyo primer elemento es un string o un
* array con los nombres de los campos de la db a utilizar
* y el segundo argumento es una funcion
* callback a llamar con el valor del campo (o los
* campos si se paso un array de campos) como
* argumento para darle formato:
* @code $tabla->addRowsData('%s',
* array('campo1', array(array('campo2', 'campo3'), 'callback_campo_2_3'))));
* function callback_campo_2_3($campos) {
* return strtoupper($campos['campo2']) . ', ' . strtolower($campos['campo3']);
* } @endcode
* Para ver un ejemplo de una callback con muchos
* parametros ver la descripcion detallada de esta funcion.
* Si no se encuentra la funcion callback, se toma como
* un string para formatear el campo con sprintf():
* @code $tabla->addRowsData('%s', array('campo1',
* array('campo2', 'campo2 = %s')); @endcode
* @param string $lugar Indica donde hay que agregar la columna. Puede ser:
* 'prepend' o 'append':
* @code $tabla->addRowsData('Hola %s!', 'nombre',
* 'prepend'); @endcode
*
* @warning Este método debe ser llamado antes de llamar a addRows().
* @note Las funciones callback toman todas un solo argumento (el valor del
* campo a formatear) y deben devolver un string con el campo
* formateado.
*/
function addRowsData($format, $campos = array(), $lugar = 'append') {
if (!is_array($campos)) {
$campos = array($campos);
}
switch (strtolower($lugar)) {
case 'prepend':
$this->_prependRowsData[] = array($format, $campos);
break;
case 'append':
$this->_appendRowsData[] = array($format, $campos);
break;
default:
$this->raiseError('Lugar incorrecto. Lugares soportados: append, prepend.');
}
}
/**
* Contruye una columna personalizada.
*
* @param array $data Datos sobre la columna, en el formato especificado
* para un elemento del array usado en _prependRowsData.
* @param mixed $row Fila de un resultado de una base de datos. Puede ser un
* array asociativo o un objeto (en cuyo caso cada campo
* debe ser un atributo del mismo).
*
* @return mixed Columna formateada para agregar a la tabla.
*
* @protected
*/
function _buildCustomColumn($data, $row) {
list($format, $campos) = $data;
// Si tiene formatos y argumentos.
if ($campos) {
// Si el formato es un MECON_HTML_Link, uso como formato a
// su contenido.
if (is_a($format, 'mecon_html_link')) {
$args = array($format->getContents());
} else {
$args = array($format);
}
// Proceso cada agumento.
foreach ($campos as $campo) {
// Si el agumento es un array, usa una callback para
// darle formato.
if (is_array($campo)) {
list($campo, $callback) = $campo;
}
if (is_array($row)) {
if (is_array($campo)) {
foreach ($campo as $c) {
$tmp[$c] = $row[$c];
}
$campo = $tmp;
}
else {
$campo = $row[$campo]; // Es un campo de un array.
}
} else { //$row es un objeto
if (is_array($campo)) {
foreach ($campo as $c) {
$tmp[$c] = $row->$c;
}
$campo = $tmp;
}
else {
$campo = $row->$campo; // Es un atributo de un objeto.
}
}
// Si usa callback, cambio el campo por el resultado del
// llamado a su callback.
if (isset($callback)) {
if(function_exists($callback)) {
$campo = $callback($campo);
} else {
//Si no existe la funcion de callback usa el callback como
//formato y los campos como argumentos para el sprintf
array_unshift($campo, $callback);
$campo = call_user_func_array('sprintf', $campo);
}
}
unset($callback);
// Agrego argumento procesado a la lista de argumentos.
$args[] = $campo;
}
// Si es un link, le seteo los contenidos procesados.
if (is_a($format, 'mecon_html_link')) {
$format->setContents(call_user_func_array('sprintf', $args));
// Si no formateo la cadena con los argumentos procesados.
} else {
$format = call_user_func_array('sprintf', $args);
}
}
// Si es un link, traduce las variables GET.
if (is_a($format, 'mecon_html_link')) {
$format = $this->_translateGetVars($format, $row);
}
// devuelve la columna.
return $format;
}
/**
* Traduce las variables GET de un link.
* Puede formatearlas con printf() o llamando una callback.
*
* @param MECON_HTML_Link $link Link con las variables GET a formatear.
* @param mixed $row Fila de un resultado de una base de dotos. Puede ser un
* array asociativo o un objeto (en cuyo caso cada campo
* debe ser un atributo del mismo).
*
* @return MECON_HTML_Link Link con las variables GET traducidas.
*
* @protected
*/
function _translateGetVars($link, $row) {
$vars = $link->getGetVars();
foreach ($vars as $var => $val) {
if (preg_match("/^{$this->_getVarPrefix}(.+)$/", $var, $m)) {
$campo = $m[1];
$campo = is_array($row) ? $row[$campo] : $row->$campo;
// Si no tiene valor, se lo reemplaza por el
// valor del campo.
if ($val === null) {
$link->setGetVar($var, $campo);
// Si existe una funcion, se la usa para obtener
// el formato.
} elseif (function_exists($val)) {
$link->setGetVar($var, $val($campo));
// Si no es ni null ni link, lo toma como
// formato para el sprintf
} else {
$link->setGetVar($var, sprintf($val, $campo));
}
}
}
return $link;
}
/**
* Agrega un ícono predefinido a la tabla.
* Ejemplo:
* @code
* $tabla = new MECON_HTML_TablaDB('personas', array('width' => '100%'));
* $result = $db->query('SELECT nombre, apellido FROM tabla');
* if (DB::isError($result)) {
* trigger_error('Error', E_USER_ERROR);
* }
* $tabla->addRow(array('Col1', 'Nombre', 'Apellido', 'Modificar', 'Borrar',
* 'Agregar'), 'cabecera');
* // Agrega ícono de modificar que apunta a modificar.php y pasa el 'id'.
* $tabla->addRowsIcon('modificar', 'id', 'modificar.php');
* // Agrega ícono de borrar desactivado.
* $tabla->addRowsIcon('no_borrar');
* // Agrega ícono con una flecha que apunta a agregar.php y no pasa nada.
* $tabla->addRowsIcon('ir', null, 'modificar.php');
* // Agrega resultados de la tabla.
* $tabla->addRows($result, array('nombre', 'apellido'));
* $tabla->display();
* @endcode
*
* @param string $id Identificador del tipo de ícono a agregar. Puede ser:
*
*
'modificar': Ícono de modificar.
*
'no_modificar': Ícono de modificar desactivado.
*
'borrar': Ícono de borrar.
*
'no_borrar': Ícono de borrar desactivado.
*
'ir': Flecha hacia la derecha.
*
* @param mixed $campos Campos de la DB a usar para generar el link. Estos
* campos serán pasados por GET a la página destino.
* Cada campo es pasado como la variable GET compuesta
* por el @ref getGetVarPrefix "prefijo" más el nombre
* del campo (ver parámetro $campos de addRowsData()
* para conocer de que formas se puede formatear un
* campo).
* @param mixed $link Si es un string, se usa como URL del link a generar.
* Si es un MECON_HTML_Link, se usa como base para el
* link a generar y se le va agregando las variables de
* GET generadas por el parámetro $campos (el link es
* procesado de la misma forma en que es procesado el
* parámetro $formato en addRowsData() con la excepción
* de que el contenido del Link no es tomado en cuenta).
* @param string $lugar Indica donde hay que agregar la columna. Puede ser:
* 'prepend' o 'append'.
*
* @warning Este método debe ser llamado antes de llamar a addRows().
* @note Las funciones callback toman todas un solo argumento (el valor del
* campo a formatear) y deben devolver un string con el campo
* formateado.
*/
function addRowsIcon($id, $campos = array(), $link = null, $lugar = 'append') {
if (!$campos) {
$campos = array();
}
if (is_string($campos)) {
$campos = array($campos);
}
if (!$link) {
$link = @$_SERVER['PHP_SELF'];
}
if (is_string($link)) {
$link = new MECON_HTML_Link($link, '');
}
switch ($id) {
case 'modificar':
$img = new MECON_HTML_Image('/MECON/images/general_modificar', '(M)');
$img->updateAttributes(array('title' => 'Modificar'));
$link->addContents($img);
foreach ($campos as $campo) {
$format = null;
if (is_array($campo)) {
list($campo, $format) = $campo;
}
$link->setGetVar($this->_getVarPrefix.$campo, $format);
}
$this->addRowsData($link, array(), $lugar);
break;
case 'no_modificar':
$img = new MECON_HTML_Image('/MECON/images/general_modificar_des', '(-)');
$img->updateAttributes(array('title' => 'Modificar'));
$this->addRowsData($img, array(), $lugar);
break;
case 'borrar':
$img = new MECON_HTML_Image('/MECON/images/general_eliminar', '(E)');
$img->updateAttributes(array('title' => 'Borrar'));
$link->addContents($img);
foreach ($campos as $campo) {
$link->setGetVar($this->_getVarPrefix.$campo, null);
}
$this->addRowsData($link, array(), $lugar);
break;
case 'no_borrar':
$img = new MECON_HTML_Image('/MECON/images/general_eliminar_des', '(-)');
$img->updateAttributes(array('title' => 'Borrar'));
$this->addRowsData($img, array(), $lugar);
break;
case 'ir':
$img = new MECON_HTML_Image('/MECON/images/general_ir4', '=>');
$img->updateAttributes(array('title' => 'Ir'));
$link->addContents($img);
foreach ($campos as $campo) {
$link->setGetVar($this->_getVarPrefix.$campo, null);
}
$this->addRowsData($link, array(), $lugar);
break;
default:
$this->raiseError("No hay un ícono predefinido llamado '$id'.");
}
}
}
?>