lib/MECON/HTML/TablaDB.php

   1 <?php /* vim: set binary expandtab tabstop=4 shiftwidth=4 textwidth=80:
   2 -------------------------------------------------------------------------------
   3                              Ministerio de Economía
   4                                     meconlib
   5 -------------------------------------------------------------------------------
   6 This file is part of meconlib.
   7
   8 meconlib is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2 of the License, or (at your option)
  11 any later version.
  12
  13 meconlib is distributed in the hope that it will be useful, but WITHOUT
  14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License; if not,
  18 write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19 Boston, MA  02111-1307  USA
  20 -------------------------------------------------------------------------------
  21 Creado: fri mar 21 ART 2003
  22 Autor:  Martin Marrese <mmarre@mecon.gov.ar>
  23 -------------------------------------------------------------------------------
  24 $Id$
  25 -----------------------------------------------------------------------------*/
  26
  27 require_once 'DB.php';
  28 require_once 'MECON/DB/Pager.php';
  29 require_once 'MECON/HTML/Error.php';
  30 require_once 'MECON/HTML/Link.php';
  31 require_once 'MECON/HTML/Tabla.php';
  32
  33 /**
  34  * Libreria para le manejo de las tablas de los sistemas de intranet.
  35  *
  36  */
  37 class MECON_HTML_TablaDB extends MECON_HTML_Tabla {
  38
  39     /**
  40      * Descripción de los elementos listados.
  41      * Se utiliza en mensajes del paginador y otros mensajes.
  42      */
  43     var $_desc = 'resultados';
  44
  45     /**
  46      * Datos a agregar delante de cada fila que se agregue desde una base de datos.
  47      * Cada elemento del array es a su vez un array cuyo primer elemento es el
  48      * formato del texto a agregar (tipo printf()) y el segundo es un array con los
  49      * campos de la DB a utilizar para ese formato en una fila dada.
  50      */
  51     var $_prependRowsData = array();
  52
  53     /**
  54      * Datos a agregar al final de cada fila que se agregue desde una base de datos.
  55      * El formato es el mismo que el de _prependRowsData.
  56      */
  57     var $_appendRowsData = array();
  58
  59     /**
  60      * Prefijo a usar para las variables GET que genera la tabla.
  61      */
  62     var $_getVarPrefix = 'tabladb_';
  63
  64     /**
  65      * Constructor.
  66      * Puede recibir como parametro un string con los atributos que se
  67      * quieren dar a la tabla en cuestion. Estos atributos estan
  68      * seteados por default segun el archivo de configuracion.
  69      * Ademas puede recibir la indicacion de algun estilo en particular.
  70      *
  71      * @param string $desc Descripción de los elementos listados.
  72      * @param mixed $attrs Atributos diferentes a los estandares para la tabla
  73      * @param string $estilo Tipo de tabla
  74      *
  75      * @access public
  76      */
  77     function MECON_HTML_TablaDB($desc = null, $attrs = null, $estilo = 'comun') {
  78         if ($desc) {
  79             $this->_desc = $desc;
  80         }
  81         parent::MECON_HTML_Tabla($attrs, $estilo);
  82     }
  83
  84     /**
  85      * Establece el prefijo usado para las variables de GET que genera la tabla.
  86      */
  87     function setGetVarPrefix($prefix) {
  88         $this->_getVarPrefix = $prefix;
  89     }
  90
  91     /**
  92      * Obtiene el prefijo usado para las variables de GET que genera la tabla.
  93      */
  94     function getGetVarPrefix() {
  95         return $this->_getVarPrefix;
  96     }
  97
  98     /**
  99      * Agrega un páginador a la tabla, basado en un resultado de una base de datos.
 100      * Ejemplo:
 101      * @code
 102      * $tabla = new MECON_HTML_TablaDB('personas', array('width' => '100%'));
 103      * $result = $db->query('SELECT nombre, apellido FROM tabla');
 104      * if (DB::isError($result)) {
 105      *      die('Error');
 106      * }
 107      * // Agrega el paginador por defecto y lo guarda para mostrar solo los
 108      * // resultados paginados después.
 109      * $pager = $tabla->addPager($result);
 110      * // Agrega cabecera con los nombres de las columnas.
 111      * $tabla->addRow(array('Nombre', 'Apellido'), 'cabecera');
 112      * // Agrega los resultados paginados de la DB.
 113      * $tabla->addRows($pager, array('nombre', 'apellido'));
 114      * $tabla->display();
 115      * @endcode
 116      *
 117      * @param DB_Result $result Resultado de una consulta de base de datos.
 118      * @param mixed $tipo Tipo de link(s) a agregar. Puede ser:
 119      *                    <ul>
 120      *                      <li><tt>'anterior'</tt></li>
 121      *                      <li><tt>'siguiente'</tt></li>
 122      *                      <li><tt>'paginas'</tt></li>
 123      *                      <li><tt>'total'</tt></li>
 124      *                      <li><tt>'info'</tt></li>
 125      *                    </ul>
 126      *                    Puede pasarse uno solo como un string o varios como un
 127      *                    array. Si se pasa <tt>'todo'</tt>, se incluyen todos.
 128      *                    Si se pasa null, se incluyen <tt>'anterior'</tt>,
 129      *                    <tt>'siguiente'</tt> y <tt>'paginas'</tt>.
 130      * @param mixed $link Dirección a la que apuntan los links generados. Puede
 131      *                    ser un MECON_HTML_Link (para poder pasar variables por
 132      *                    GET) o un string.
 133      * @param int $limit Parámetro usado para crear el MECON_DB_Pager.
 134      * @param int $maxpages Parámetro usado para crear el MECON_DB_Pager.
 135      * @param string $getvar Nombre de la variable GET a usar para indicar el número
 136      *               de página actual (se le pone el \ref setGetPrefix prefijo)
 137      *
 138      * @return MECON_DB_Pager Pager que se puede usar para realizar los fetch de
 139      *         los resultados de la página actual.
 140      *
 141      * @see MECON_DB_Pager, addRows().
 142      */
 143     function addPager($result, $tipo = null, $link = null, $limit = 10, $maxpages = 21, $getvar = 'from') {
 144         // Creo el pager con el resultado.
 145         $pager = new MECON_DB_Pager($result, @$_GET[$this->_getVarPrefix.$getvar], $limit, $maxpages);
 146         // Obtengo un link válido.
 147         if (!$link) {
 148             $link = @$_SERVER['PHP_SELF'];
 149         }
 150         if (is_string($link)) {
 151             $link = new MECON_HTML_Link($link, '');
 152         }
 153         // Si es el tipo por defecto pone paginador nada más.
 154         if (!$tipo) {
 155             $tipo = array('anterior', 'paginas', 'siguiente');
 156         }
 157         // Convierte tipo a array.
 158         if (!is_array($tipo)) {
 159             $tipo = array($tipo);
 160         }
 161         // Si se quiere mostrar todas las decoraciones del paginador.
 162         if (in_array('todo', $tipo)) {
 163             $tipo = array('anterior', 'paginas', 'siguiente', 'total', 'info');
 164         }
 165         // Me fijo si tiene cada uno de los elementos y los agrego.
 166         if (in_array('anterior', $tipo) and $pager->numRows() and $pager->currentpage != 1) {
 167             $link->setGetVar($this->_getVarPrefix.$getvar, $pager->prev);
 168             $this->addLink('anterior', $link);
 169         }
 170         if (in_array('siguiente', $tipo) and $pager->numRows() and $pager->currentpage != $pager->numpages) {
 171             $link->setGetVar($this->_getVarPrefix.$getvar, $pager->next);
 172             $this->addLink('siguiente', $link);
 173         }
 174         if (in_array('paginas', $tipo) and $pager->numRows() and $pager->numpages > 1) {
 175             $from = @$_GET[$this->_getVarPrefix.$getvar];
 176             $pags = '';
 177             $lnk = $link->getContents();
 178             foreach ($pager->pages as $page => $start_row) {
 179                 if ($start_row == $from) {
 180                     $pags .= $page;
 181                 } else {
 182                     $link->setGetVar($this->_getVarPrefix.$getvar, $start_row);
 183                     $link->setContents($page);
 184                     $pags .= $link->toHtml();
 185                 }
 186                 if ($page != $pager->lastpage) {
 187                     $pags .= ' | ';
 188                 }
 189             }
 190             $link->setContents($lnk);
 191             $this->updatePie($pags, 'centro');
 192         }
 193         if (in_array('total', $tipo) and $pager->numRows()) {
 194             $this->updateCabecera("Se encontraron {$pager->numrows} {$this->_desc}.", 'izquierda');
 195         }
 196         if (in_array('info', $tipo) and $pager->numRows()) {
 197             $this->updateCabecera("'Página {$pager->currentpage} de {$pager->numpages} - "
 198                 . "{$pager->limit} {$this->_desc} por página.", 'derecha');
 199         }
 200         return $pager;
 201     }
 202
 203     /**
 204      * Agrega filas desde el resultado de una consulta a una base de datos.
 205      * Si no hay resultados, muestra un mensaje. Dependiendo de si es se pasa
 206      * un objeto a usar o no, llama a addRowsObject() o addRowsResult()
 207      * respectivamente.
 208      *
 209      * @param DB_Result $result Resultados de una consulta.
 210      * @param array $campos Propiedades del objeto a mostrar.
 211      * @param mixed $obj Objeto a usar. Puede ser un objeto instanciado o un
 212      *                   string con el nombre de la clase.
 213      *
 214      * @see addRowsData(), addRowsIcon(), ejemplo en addPager().
 215      */
 216     function addRows($result, $campos, $obj = null) {
 217         if ($result->numRows()) {
 218             if ($obj) {
 219                 $this->addRowsObject($result, $campos, $obj);
 220             } else {
 221                 $this->addRowsResult($result, $campos, $obj);
 222             }
 223         } else {
 224             $id = $this->addRow(array(new MECON_HTML_Error("No se encontraron {$this->_desc}.")));
 225             $this->updateCellAttributes($id, 0, array('colspan' => count($campos)));
 226         }
 227     }
 228
 229     /**
 230      * Agrega filas usando un resultado.
 231      *
 232      * @param DB_Result $result Resultados de una consulta.
 233      * @param array $campos Campos de la base de datos a mostrar.
 234      */
 235     function addRowsResult($result, $campos) {
 236         while ($row = $result->fetchRow(DB_FETCHMODE_ASSOC)) {
 237             $columnas = array();
 238             foreach ($this->_prependRowsData as $data) {
 239                 $columnas[] = $this->_buildCustomColumn($data, $row);
 240             }
 241             foreach ($campos as $campo) {
 242                 $columnas[] = $row[$campo];
 243             }
 244             foreach ($this->_appendRowsData as $data) {
 245                 $columnas[] = $this->_buildCustomColumn($data, $row);
 246             }
 247             $this->addRow($columnas);
 248         }
 249     }
 250
 251     /**
 252      * Agrega filas usando un objeto.
 253      * El objeto debe tener un método llamado cargar que acepte como primer (y
 254      * único obligatorio) parámetro un DB_Result para cargar sus datos desde una
 255      * base de datos.
 256      *
 257      * @param DB_Result $result Resultados de una consulta.
 258      * @param array $campos Propiedades del objeto a mostrar.
 259      * @param mixed $obj Objeto a usar. Puede ser un objeto instanciado o un
 260      *                   string con el nombre de la clase.
 261      *
 262      * @see La interfaz MECON_DBO que tiene el método MECON_DBO::cargar().
 263      */
 264     function addRowsObject($result, $campos, $obj) {
 265         if (is_string($obj)) {
 266             $obj = new $obj;
 267         }
 268         if (!method_exists($obj, 'cargar')) {
 269             $this->raiseError('La clase ' . get_class($obj) . ' no tiene un metodo cargar().');
 270         }
 271         while ($obj->cargar($result)) {
 272             foreach ($this->_prependRowsData as $data) {
 273                 $columnas[] = $this->_buildCustomColumn($data, $row);
 274             }
 275             foreach ($campos as $campo) {
 276                 $columnas[] = $obj->$campo;
 277             }
 278             foreach ($this->_appendRowsData as $data) {
 279                 $columnas[] = $this->_buildCustomColumn($data, $row);
 280             }
 281             $this->addRow($columnas);
 282         }
 283     }
 284
 285     /**
 286      * Agrega una columna arbitraria a la tabla basado en valores de una fila.
 287      * Ejemplo:
 288      * @code
 289      * $tabla = new MECON_HTML_TablaDB('personas', array('width' => '100%'));
 290      * $result = $db->query('SELECT nombre, apellido, activo FROM tabla');
 291      * if (DB::isError($result)) {
 292      *      die('Error');
 293      * }
 294      * $tabla->addRow(array('Col1', 'Nombre', 'Apellido', 'Activo'), 'cabecera');
 295      * // Agrega una columna con una leyenda 'El nombre es: {nombre}' al principio.
 296      * $tabla->addRowsData('Me llamo %s.', 'nombre', 'prepend');
 297      * // Agrega una columna al final con checkbox para seleccionar filas. El
 298      * // segundo elemento será procesado por la callback checked_callback().
 299      * $tabla->addRowsData('<input type="checkbox" name="datos[%s]" value="1" %s />',
 300      *          array('nombre', array('activo', 'checked_callback')));
 301      * // Agrega resultados de la tabla.
 302      * $tabla->addRows($result, array('nombre', 'apellido'));
 303      * $tabla->display();
 304      * @endcode
 305      *
 306      * @param mixed $format Si es un string, especifica el formato a usar al
 307      *                      estilo de sprintf. Si es un MECON_HTML_Link, se
 308      *                      traduce cada variable por GET que empiece con el
 309      *                      \ref getGetVarPrefix "prefijo" y cuyo valor sea null
 310      *                      al campo correspondiente de la DB. Si e valor en vez
 311      *                      de ser null es un string, se fija si existe una
 312      *                      función con ese nombre para llamar con el campo de
 313      *                      la DB como argumento para formatearlo. Si no existe
 314      *                      la función, se toma el string como formato para
 315      *                      sprintf para darle formato.
 316      * @param mixed $campos Campos de la DB a usar como argumentos del sprintf.
 317      *                      Puede ser un string para pasar un solo campo sin
 318      *                      formato. Si es un array, cada elemento es un campo
 319      *                      que puede ser un string representando el nombre de
 320      *                      un campo a usar sin agumento o un array cuyo primer
 321      *                      elemento es el nombre del campo a usar y el segundo
 322      *                      argumento es una funcion callback a llamar con el
 323      *                      valor del campo como argumento para darle formato.
 324      *                      @code $tabla->addRowsData('%s', array('campo1', 'campo2', array('campo3', 'callback_campo3')))); @endcode
 325      * @param string $lugar Indica donde hay que agregar la columna. Puede ser:
 326      *                      <tt>prepend</tt> o <tt>append</tt>.
 327      *
 328      * @warning Este método debe ser llamado antes de llamar a addRows().
 329      * @note Las funciones callback toman todas un solo argumento (el valor del
 330      *       campo a formatear) y deben devolver un string con el campo
 331      *       formateado.
 332      */
 333     function addRowsData($format, $campos = array(), $lugar = 'append') {
 334         if (!is_array($campos)) {
 335             $campos = array($campos);
 336         }
 337         switch (strtolower($lugar)) {
 338             case 'prepend':
 339                 $this->_prependRowsData[] = array($format, $campos);
 340                 break;
 341             case 'append':
 342                 $this->_appendRowsData[] = array($format, $campos);
 343                 break;
 344             default:
 345                 $this->raiseError('Lugar incorrecto. Lugares soportados: append, prepend.');
 346         }
 347     }
 348
 349     /**
 350      * Contruye una columna personalizada.
 351      *
 352      * @param array $data Datos sobre la columna, en el formato especificado
 353      *                    para un elemento del array usado en _prependRowsData.
 354      * @param mixed $row Fila de un resultado de una base de dotos. Puede ser un
 355      *                   array asociativo o un objeto (en cuyo caso cada campo
 356      *                   debe ser un atributo del mismo).
 357      *
 358      * @return mixed Columna formateada para agregar a la tabla.
 359      *
 360      * @protected
 361      */
 362     function _buildCustomColumn($data, $row) {
 363         list($format, $campos) = $data;
 364         // Si tiene formatos y argumentos.
 365         if ($campos) {
 366             // Si el formato es un MECON_HTML_Link, uso como formato a
 367             // su contenido.
 368             if (is_a($format, 'mecon_html_link')) {
 369                 $args = array($format->getContents());
 370             } else {
 371                 $args = array($format);
 372             }
 373             // Proceso cada agumento.
 374             foreach ($campos as $campo) {
 375                 // Si el agumento es un array, usa una callback para
 376                 // darle formato.
 377                 if (is_array($campo)) {
 378                     list($campo, $callback) = $campo;
 379                 }
 380                 if (is_array($row)) {
 381                     $campo = $row[$campo]; // Es un campo de un array.
 382                 } else {
 383                     $campo = $row->$campo; // Es un atributo de un objeto.
 384                 }
 385                 // Si usa callback, cambio el campo por el resultado del
 386                 // llamado a su callback.
 387                 if (isset($callback) and function_exists($callback)) {
 388                     $campo = $callback($campo);
 389                 }
 390                 // Agrego argumento procesado a la lista de argumentos.
 391                 $args[] = $campo;
 392             }
 393             // Si es un link, le seteo los contenidos procesados.
 394             if (is_a($format, 'mecon_html_link')) {
 395                 $format->setContents(call_user_func_array('sprintf', $args));
 396             // Si no formateo la cadena con los argumentos procesados.
 397             } else {
 398                 $format = call_user_func_array('sprintf', $args);
 399             }
 400         }
 401         // Si es un link, traduce las variables GET.
 402         if (is_a($format, 'mecon_html_link')) {
 403             $format = $this->_translateGetVars($format, $row);
 404         }
 405         // devuelve la columna.
 406         return $format;
 407     }
 408
 409     /**
 410      * Traduce las variables GET de un link.
 411      * Puede formatearlas con printf() o llamando una callback.
 412      *
 413      * @param MECON_HTML_Link $link Link con las variables GET a formatear.
 414      * @param mixed $row Fila de un resultado de una base de dotos. Puede ser un
 415      *                   array asociativo o un objeto (en cuyo caso cada campo
 416      *                   debe ser un atributo del mismo).
 417      *
 418      * @return MECON_HTML_Link Link con las variables GET traducidas.
 419      *
 420      * @protected
 421      */
 422     function _translateGetVars($link, $row) {
 423         $vars = $link->getGetVars();
 424         foreach ($vars as $var => $val) {
 425             if (preg_match("/^{$this->_getVarPrefix}(.+)$/", $var, $m)) {
 426                 $campo = $m[1];
 427                 $campo = is_array($row) ? $row[$campo] : $row->$campo;
 428                 // Si no tiene valor, se lo reemplaza por el
 429                 // valor del campo.
 430                 if ($val === null) {
 431                     $link->setGetVar($var, $campo);
 432                 // Si existe una funcion, se la usa para obtener
 433                 // el formato.
 434                 } elseif (function_exists($val)) {
 435                     $link->setGetVar($var, $val($campo));
 436                 // Si no es ni null ni link, lo toma como
 437                 // formato para el sprintf
 438                 } else {
 439                     $link->setGetVar($var, sprintf($val, $campo));
 440                 }
 441             }
 442         }
 443         return $link;
 444     }
 445
 446     /**
 447      * Agrega un ícono predefinido a la tabla.
 448      *
 449      * @param string $id Identificador del tipo de ícono a agregar. Puede ser:
 450      *                   <ul>
 451      *                     <li><tt>'modificar'</tt>: Ícono de modificar.</li>
 452      *                     <li><tt>'no_modificar'</tt>: Ícono de modificar desactivado.</li>
 453      *                     <li><tt>'borrar'</tt>: Ícono de borrar.</li>
 454      *                     <li><tt>'no_borrar'</tt>: Ícono de borrar desactivado.</li>
 455      *                     <li><tt>'ir'</tt>: Flecha hacia la derecha.</li>
 456      *                   </ul>
 457      * @param mixed $campos Campos de la DB a usar para generar el link. Estos
 458      *                      campos serán pasados por GET a la página destino.
 459      *                      Cada campo es pasado como la variable GET compuesta
 460      *                      por el @ref getGetVarPrefix "prefijo" más el nombre
 461      *                      del campo (ver parámetro $campos de addRowsData()
 462      *                      para conocer de que formas se puede formatear un
 463      *                      campo).
 464      * @param mixed $link Si es un string, se usa como URL del link a generar.
 465      *                    Si es un MECON_HTML_Link, se usa como base para el
 466      *                    link a generar y se le va agregando las variables de
 467      *                    GET generadas por el parámetro $campos (el link es
 468      *                    procesado de la misma forma en que es procesado el
 469      *                    parámetro $formato en addRowsData() con la excepción
 470      *                    de que el contenido del Link no es tomado en cuenta).
 471      * @param string $lugar Indica donde hay que agregar la columna. Puede ser:
 472      *                      <tt>prepend</tt> o <tt>append</tt>.
 473      *
 474      * @warning Este método debe ser llamado antes de llamar a addRows().
 475      * @note Las funciones callback toman todas un solo argumento (el valor del
 476      *       campo a formatear) y deben devolver un string con el campo
 477      *       formateado.
 478      */
 479     function addRowsIcon($id, $campos = array(), $link = null, $lugar = 'append') {
 480         if (is_string($campos)) {
 481             $campos = array($campos);
 482         }
 483         if (!$link) {
 484             $link = @$_SERVER['PHP_SELF'];
 485         }
 486         if (is_string($link)) {
 487             $link = new MECON_HTML_Link($link, '');
 488         }
 489         switch ($id) {
 490             case 'modificar':
 491                 $img = new MECON_HTML_Image('/MECON/images/general_modificar', '(M)');
 492                 $link->addContents($img);
 493                 foreach ($campos as $campo) {
 494                     $format = null;
 495                     if (is_array($campo)) {
 496                         list($campo, $format) = $campo;
 497                     }
 498                     $link->setGetVar($this->_getVarPrefix.$campo, $format);
 499                 }
 500                 $this->addRowsData($link, array(), $lugar);
 501                 break;
 502             case 'no_modificar':
 503                 $img = new MECON_HTML_Image('/MECON/images/general_modificar_des', '(-)');
 504                 $this->addRowsData($img, array(), $lugar);
 505                 break;
 506             case 'borrar':
 507                 $img = new MECON_HTML_Image('/MECON/images/general_eliminar', '(B)');
 508                 $link->addContents($img);
 509                 foreach ($campos as $campo) {
 510                     $link->setGetVar($this->_getVarPrefix.$campo, null);
 511                 }
 512                 $this->addRowsData($link, array(), $lugar);
 513                 break;
 514             case 'no_borrar':
 515                 $img = new MECON_HTML_Image('/MECON/images/general_eliminar_des', '(-)');
 516                 $this->addRowsData($img, array(), $lugar);
 517                 break;
 518             case 'ir':
 519                 $img = new MECON_HTML_Image('/MECON/images/general_ir4', '->');
 520                 $link->addContents($img);
 521                 foreach ($campos as $campo) {
 522                     $link->setGetVar($this->_getVarPrefix.$campo, null);
 523                 }
 524                 $this->addRowsData($link, array(), $lugar);
 525                 break;
 526             default:
 527                 $this->raiseError("No hay un ícono predefinido llamado '$id'.");
 528         }
 529     }
 530
 531 }
 532
 533 ?>