PHPLIB (II)
Plantillas
Ya se ha comentado que uno de los
principales problemas a la hora de
programar con PHP, o cualquier otro
lenguajes que mezcle HTML y el código,
es que el código final de las páginas
tiene mezclado los datos a presentar
y el código.
Este mezcla impide además un correcto
trabajo entre los desarrolladores
de código y los creadores de páginas
HTML y diseñadores gráficos. Para
resolver este problemo lo mejor es
intentar independizar totalmente el
código PHP y el código HTML. Este
objetivo es bastante lioso de lograr
a menos que se ataque el problema
de una forma general y se sea muy
estrícto a la hora de desarrollar
las páginas.
Los beneficios logrados por esta
separación son muy grandes incluyendo
por ejemplo el cambio de temas según
el tipo de usuario que acceda al servidor
de web, facilitar la traducción de
webs sin tocar para nada el código
facilitando así la internacionalización
del código etc.
Dentro de PHPLIB nos encontramos
con una clase que nos ayuda con este
objetivo: la clase Template.
Para ver la potencia del uso de plantillas
vamos a planter un ejemplo de unsa
sencilla página que debe de controlar
el acceso a un web y según el usuario
que entre, se debe de presentar el
web en un idioma u otro. La aplicación
lo único que hace es mostrar una serie
de datos númericos sobre cotización
en bolsa en euros, por lo que esta
información es idéntica para todos
los idiomas.
Para ello podríamos utilizar os mecanismos
de autenticación de la propia PHPLIB.
Podríamos crear una nueva tabla en
la base de datos asociando identificador
de usuario e idioma y tendríamos que
preparar los diferentes webs.
Supongamos que inicialmente tenemos
dos idiomas: español e inglés. Podemos
crear dos directorios, uno con las
plantillas en español y el otro con
las plantillas en inglés. El código
podría empezar de la forma:
page_open(array("sess" => "Example_Session", "auth" => "Example_Auth",
"perm" => "Example_Perm", "user" => "Example_User"));
// Template no es del núcleo de PHPLIB por lo que hay que
// incluir esta clase de forma explícita.
include("template.inc");
$plantillas = "/home/acs/public_html/plantillas";
$plantillasEspañol = $plantillas."/español";
$plantillasIngles= $plantillas."/ingles";
// Ya sabemos que usuario es $auth[uname]
// La función miraIdioma accedería a la base de datos para ver que
// idioma le corresponde a un usuario.
$idioma=miraIdioma ($auth[uname]);
if ($idioma=="español") $t=new Template($plantillasEspañol);
elseif ($idioma=="ingles") $t=new Template($plantillasIngles);
else {echo "Error en la selección de idioma.";exit;}
// Tenemos dos plantillas: una para la cabecera y otra para el cuerpo
$t->set_file(array(
"cabecera" => "cabecera.ihtml",
"cuerpo" => "cuerpo.ihtml"));
// Suponemos que existe una función que nos devuelve los valores
// a presentar.
$valores = obtenValores();
$fecha = date("d/m/a");
// Cada plantilla puede contener un número de variables cuyo
// valor se controla desde el código a través de Template
$t->set_var(array("Fecha" => $fecha,
"Valores" => $valores));
$t->parse("OUT", array("cabecera", "cuerpo"));
/* imprimimos OUT */
$t->p("OUT");
Todas las plantillas asociadas a
un objeto Template han de encontrarse
en un directorio. En nuesto ejemplo
según el idioma se cogen del directorio
en inglés o del español. Una vez asignado
el directorio a través de la función
"set_file" asociamos plantillas a
nombres. De esta forma en nuestro
programa utilizaremos los nombres
aquí indicados para referirnos a la
plantilla a utilizar. En este sencillo
ejemplo sólo hay dos plantillas "cabecera.ihtml"
y "cuerpo.ihtml".
Aparte de definir las plantillas
con las que vamos a trabajar hay que
definir las variables que hay que
sustituir en dichas plantillas. Cualquier
ocurrencia de una variable dentro
de una plantilla es sustituido por
el valor que le asociamos a través
de "set_var". En nuestro caso la varible
"{Fecha}" se sutituye por "$fecha"
y "{Valores}" por $valores.
Por ejemplo, el contenido de "cabecera.ihtml"
podría ser:
<html>
<head>
<title>Valores de cotización
<title>
<head>
<body>
Fecha de los valores: {Fecha}
El valor de "{Fecha}" será sustituido
de forma automática cuando ejecutemos
la función de sustitución de valores
"parse". El resultado lo almacenamos
en la variable "OUT" que imprimimos
finalmente con la función "p()".
Las plantillas que se incluyen en
PHPLIB tienen una funcionalidad más
amplia y sugerimos al lector una lectura
de la documentación de PHPLIB para
ver todas sus posibilidades.
La cesta de
la compra
Ya dijimos que gracias al control
de sesiones sería trivial construir
una cesta de la compra. Pues PHPLIB
incluye una clase llamada "Cart" que
es precisamente esto, una cesta de
la compra.
El comercio electrónico siempre obliga
a que a la hora de comprar el cliente
vaya teniendo su cesta de la compra
con los productos que ha ido adquiriendo.
El mecanismo por el que se suele mantener
este estdo del cliente es mediante
cookies, aunque ya vismo que PHPLIB
podía evitar el uso de "cookies" utilizando
el método GET.
La cesta de la compra en PHPLIB es
un conjunto de artículos que se almacenan
en la base de datos. PHPLIB nos proporciona
una API sencillo para añadir, consultar
o borrar la lista de artículos en
la bolsa de la compra. Para crear
nuestra cesta de la compra necesitaremos
en general realizar una nueva clase
de cesta de la compra basada en "Cart",
principalmente para controlar la visualización
de los productos, tal y como se muestra
a continuación:
class Mi_Cesta extends Cart {
var $classname = "Mi_Cesta";
// Base de datos donde guardamos los artículos
var $database_class = "DB_Article";
var $database_table = "articles";
var $db;
var $sum = 0;
function show_cart_open() {
printf("<table class=cart_table>n");
$this->sum = 0;
}
function show_cart_close() {
printf("</table>\n");
printf("That's a total of %s.\n", $this->sum);
}
function show_item($art, $num) {
if (!is_object($this->db)) {
$class = $this->database_class;
$this->db = new $class;
}
$query = sprintf("select * from %s where artid = '%s'",
$this->database_table,
$art);
$this->db->query($query);
while($this->db->next_record()) {
printf(" <tr class=cart_row>\n <td class=cart_cell>%s</td>\n",
$this->db->Record["name"]);
printf(" <td class=cart_cell>%s</td>\n",
$this->db->Record["price"]);
printf(" <td class=cart_cell>%s</td>\n",
$num);
$rowsum = $num * $this->db->Record["price"];
$this->sum += $rowsum;
printf(" <td class=cart_cell>%s</td>\n",
$rowsum);
printf(" <tr>\n");
}
}
}
Para utilizar la clase "Cart" vamos
a necesitar crear una tabla más donde
se encuentren la descripción de todos
los artículos que vendamos en nuestra
tienda. Esta tabla la podemos crear
dentro de una base de datos propia
para cada uno de nuestros clientes,
base de datos que también deberá tener
la información de "active_sessions"
y "auth_user".
Un ejemplo sencillo podría ser:
#
# Estructura de la tabla de 'articles'
#
CREATE TABLE articles (
name text,
price float(8,2),
artid int(11) DEFAULT '0' NOT NULL auto_increment,
PRIMARY KEY (artid)
);
En la documentación de PHPLIB se
encuentran todos los detalles necesarios
para un uso completo de esta clase.
Su descripción completa desbordaría
el espacio del que disponemos para
este artículo.
HTML Widgets
PHPLIB incluye también un conjunto
de clases para facilitar la creación
de código HTML. Por un lado con Sql_Query
podemos construir formularios HTML
a partir de los cuales hacer peticiones
SQL a una base de datos.
Con Table podemos construir tablas
HTML de una forma sencilla, muy útil
para presentar el contenido de matrices
de datos y de resultados de consultas
a una base de datos.
Menu es un widget que a partir de
un árbol genera un menú jerárquico
con enlaces que se puede utilizar
como barra de navegación. De esta
forma se puede facilitar mucho la
creación de este tipo de barras de
navegación, que siempre son muy engorrosas
de mantener y que, en muchos casos,
llevan a los diseñadores web al uso
de marcos (frames) en sus páginas.
OOHForms es un widget para la construcción
de formularios con la ventaja de que
puede utilizar Javascript y SSI para
comprobar que los valores de los campos
del formulario son correctos. Antes
de enviar el formulario se pueden
chequear los valores que los campos
del formulario, evitando así el envío
de datos que desde su origen sus erróneos.
Por último existen dos últimos widget:
"tpl_form" para la construcción de
formularios utilizando OOHForms pero
a un nivel de abstracción mayor (el
objeto es una caja negra de la que
podemos obtener datos, pero no sabemos
como se obtienen) y Tree que permite
representar en HTML estructuras de
datos complejas en árbol como subdirectorios.
Resumen de PHPLIB
En la segundo entrega del rincón
de PHP en Linux Actual os hemos presentado
PHPLIB, una librería orientada a objetos
que facilita en gran medida las necesidades
más básicas a la hora de montar un
sitio web basado en PHP: control de
sesiones y de identidad. Junto a estas
necesidades básicas PHPLIB nos ofrece
también clases para programar nuestros
sitios utilizando plantillas lo facilita
el trabajo en paralelo de desarrolladores
PHP y creadores de páginas HTML y
diseñadores gráficos.
Hemos visto también como PHPLIB no
se ha olvidado del comercio electrónico
y entre sus objetos incluye una cesta
de la compra integrada con el control
de sesiones y de autenticación. Esto
nos va a permitir montar tiendas virtuales
en Internet utilizando PHP con un
esfuerzo mínimo. Por último PHPLIB
también contiene un conjunto de widgets
que nos liberan de tareas tan arduas
como chequear los valores de un formulario
o la presentación en HTML de complejas
estructuras en árbol.
Referencias
Top Secciones de descargas
