domingo, 18 de julio de 2010

Construyendo un sitio con KumbiaPHP (2)


En la entrada anterior hice el más básico de los ejemplos en kumbia y una burda explicación de algunos de los aspectos más importantes del framework.

Tal como prometí, en esta entrada voy a trabajar un poco con las vistas y para no extender, dejaremos para la siguiente entrada un ejemplo más completo donde se intercambia información entre las capas de vista y controlador.

En primer lugar voy a comenzar trabajando un poco con los partials. Como explique anteriormente, aquí vamos a guardar códigos parciales como lo son el header o footer de nuestras plantillas. La idea es seccionar nuestro código para facilitar posteriores modificaciones.

Lo primero que haremos será crear un directorio no65 dentro del directorio views/partials. Aquí vamos a guardar los partials de nuestro tema no65.

Ahora comenzaremos a desarmar nuestro default.phtml y colocar cada sección en un partial distinto. En este caso, tenemos una plantilla clásica con: header, menú lateral, cuerpo y footer.

Voy a empezar por el footer. Creamos un archivo footer.phtml, y en el colocamos todo el código que se encuentra entre "Begin Footer" y "End Footer" de default.phtml, y lo borramos de ahí. En sustitución, en default.phtml colocaremos lo siguiente:

<!-- Begin Footer -->
<?php View::partial('no65/footer') ?>
<!-- End Footer -->

El archivo footer.phtml quedará de la siguiente forma:

<div id="footer">
<p><a href="http://validator.w3.org/">Valid CSS</a> :: <a href="http://validator.w3.org/">Valid XHTML</a></p>
<p>Copyright &copy; 2007 by Your Company</p>
<p>Template Designed By: <a href="http://web20templates.blogspot.com">Free Web 2.0 Website Templates</a></p>
</div>

Guardamos y recargamos la página en el navegador. Observamos que no hay ningún cambio, por lo que vamos por buen camino. Repetiremos lo mismo con el header y con el menú lateral. Así tendremos nuestro header, footer y menú lateral en archivos separados, lo cual facilitará la modificación de éstos por separado, y mayor legibilidad a nuestra plantilla.


Revisemos el cuerpo

El cuerpo de nuestra plantilla está compuesto actualmente por 3 divs tipo "textboxright": el que agregamos en la entrada anterior donde invocamos a View::content() y dos con códigos de ejemplo proporcionado por la plantilla.

Como no queremos mostrar los ejemplos de nuestra plantilla, lo que haremos será borrar los divs correspondientes, y para hacer más elegante nuestro código, nos llevaremos el "textboxright" donde se encuentra nuestro "Hola Twitter" al archivo hola.phtml. De esta manera dejaremos más limpio nuestro default.phtml, y además así podremos utilizar todos los textboxright que queramos dentro de nuestras vistas particulares.

El body de default.phtml quedaría así de elegante:

<body>

<!-- Begin Wrapper -->
<div id="wrapper">

<!-- Begin Header -->
<?php View::partial('no65/header') ?>
<!-- End Header -->

<!-- Begin Stripes -->
<div id="stripes">

</div>
<!-- End Stripes -->

<!-- Begin Left Column -->
<?php View::partial('no65/leftcolumn') ?>
<!-- End Left Column -->

<!-- Begin Right Column -->
<div id="rightcolumn">
<?php View::content(); ?>
</div>
<!-- End Right Column -->

<!-- Begin Footer -->
<?php View::partial('no65/footer') ?>
<!-- End Footer -->

</div>
<!-- End Wrapper -->

</body>

Demás está decir que debemos trabajar en nuestro header, footer y menú lateral, borrar lo que no necesitemos, agregar la data que nos haga falta. Cambiar el título, colocar un ícono, en fin, lo que queramos.


Tarea

En la entrada anterior colocamos nuestro archivo style.css directamente dentro de la carpeta public/css, e igual hicimos con nuestras imágenes. Si queremos mantener varios estilos, nuestros directorios css e img se van a llenar y luego no vamos a poder identificar con facilidad que archivo pertenece a cada estilo, en el caso de que necesitemos modificarlos. Lo mejor es incluir un directorio dentro css y otro dentro de img que identifique a nuestra plantilla, así como hicimos con los partials. Este cambio es bastante intuitivo, no tendrá mayor complicación.


Agregando otra plantilla

Ahora vamos a incluir en nuestro proyecto una segunda plantilla, para darnos cuenta de lo sencillo que será cambiar de una a la otra. Supongamos que nos bajamos la plantilla NonZero de http://nodethirtythree.com

A grandes rasgos, estos son los pasos que vamos a seguir:

1) Creamos nuestra plantilla nonzero.phtml dentro de views/templates

2) Creamos nuestro directorio de parciales views/partials/nonzero

3) Dentro del directorio de parciales incluiremos header.phtml, footer.phtml y en este caso un rightcolumn.phtml

4) Creamos nuestros directorios public/img/nonzero y public/css/nonzero y guardaremos en ellos los archivos correspondientes

5) Copiaremos el código de index.html de nonzero en nuestra plantilla nonzero.phtml

6) Cortar los trozos de código de nonzero.phtml y pegarlos en el partial correspondiente


Recordemos modificar la forma de llamar las imágenes y css. Recordemos también invocar a la función View::content() en el lugar correspondiente.

Si recargamos nuestro navegador, no habrá pasado nada, puesto que no hemos modificado la plantilla por omsión default.phtml. Lo que vamos a hacer es decirle a nuestro controlador saludo_controller que queremos utilizar la nueva plantilla; para ello, definiremos dentro de saludo_controller.php la variable template:

public $template = 'plantilla';

Ahora apuntamos a nuestro navegador y abrimos http://localhost/tutuitero/saludo/hola. ¿Qué estamos viendo? Estaremos en frente de nuestra nueva plantilla casi perfectamente renderizada. Y digo "casi", porque aunque el resultado general en este caso es muy bueno, recordemos que estamos utilizando dos hojas de estilo distintas y no estamos utilizando la misma convención de nombres de elementos en ambos.

Si queremos utilizar dos plantillas indistintamente, tendremos que trabajar un poco las hojas de estilo, para que utilicemos los mismos elementos en nuestras vistas.


Ejercicio sencillo

Vamos ahora a implementar una despedida (tal como hacen en el tutorial):

1) Creamos la función adios() dentro de saludo_controller.php

public function adios() {
$this->template = 'default';
}

Observe que le hemos a asignado a nuestra variable $template el valor 'default', para que tome la plantilla por omisión.

2) Creamos un documento adios.phtml dentro del directorio views/saludo

<div class="textboxright">
<h2>Adios KumbiaPHP</h2>

<?php echo link_to('saludo/hola/', 'Volver a Saludar') ?>
</div>

Observe que hemos puesto un enlace a hola, haciendo uso de la función echo_link_to(). Dentro de hola, pondremos un enlace a adios utilizando la misma función.

Ahora, haciendo clic en los enlaces estaremos cambiando tanto de función, como de plantilla.

Con este sencillo ejemplo, hemos hecho uso de templates y partials, para mantener simultáneamente dos plantillas distintas en nuestro sitio web. El uso de partials no es obligatorio, aunque recomendado para facilitar el entendimiento del código. El uso de templates agrega mucha versatilidad a nuestro sitio. Pensemos por ejemplo en que tenemos una plantilla para visitantes desde computadores, y una plantilla para visitantes desde dispositivos móviles; ésta es una de las muchas posibilidades de uso.


sábado, 17 de julio de 2010

Construyendo un sitio con KumbiaPHP


En las entradas anteriores he hecho pequeñas pruebas de conceptos, sobre archivos sin ningún tipo de estilo o presentación. Como nuestro objetivo es desarrollar aplicaciones web completas que realicen varias tareas, necesariamente tenemos que pensar en el tema del diseño web.

Como siempre, podemos hacernos nuestros sitios web desde cero, y para ser más drásticos, usando exclusivamente notepad. No es el objetivo de este blog; también como siempre, me iré por el camino más sencillo: soluciones pre-elaboradas. En la red podemos encontrar infinidad de recursos para desarrollo web: Frameworks, CMS, sistemas de plantillas, etc.

Un framework general de desarrollo me parece la opción correcta. Existen muchas opciones, entre las cuales yo me he decidido por KumbiaPHP, por 2 razones:

1) Es un framework sumamente sencillo de usar y sobre todo práctico, con el que además he trabajado previamente y que sé que facilitará el trabajo (sí, ley de mínimo esfuerzo). En este post prometo dejar una aplicación funcional que no tomará más de 30 minutos de construir.

2) En principio, nuestra aplicación no se conectará con una base de datos, pero en un futuro cercano (espero) sí lo hará. KumbiaPHP es un framework basado en MVC, que permite trabajar en primera instancia con solamente las capas de Vista y Controlador (aunque no es lo recomendable), y en cualquier momento podemos agregar la conexión a la base de datos sin ningún problema.

A pesar de que ya lo conocía, voy a hacer como si no, y construiré el sitio, paso por paso, tal como se detalla en este excelente tutorial:

Lo primero que debemos hacer es descargar la librería del sitio oficial.

Descomprimimos el archivo en nuestro directorio web y obtendremos la siguiente estructura:

kumbiaphp/
|--app
|--core
|--.htaccess
|--index.php

Para verificar que todo vaya bien, en un navegador vamos a la url de nuestro site, y debería mostrarse la página de bienvenida de kumbia.

Bien, siguiendo con el tutorial, vamos a crear nuestro 'Hola Twitter'.

1) Crearemos la vista y controlador de nuestra aplicación.
1.1) Dentro del directorio app/controllers creamos un archivo hola_controller.php
1.2) Dentro del directorio app/views creamos un directorio hola

En el archivo hola_controller.php definiremos una clase, con todas las funciones que queremos ejecutar en nuestro controlador. De momento queremos solamente imprimir un saludo por pantalla, así que sólo crearemos una función:

<?php
class SaludoController extends ApplicationController {
public function
hola()
{
//Ver metodo render
$this->render(NULL);
}
}

Por cada controlador, debemos tener un subdirectorio dentro del directorio de vistas (app/views), y por cada función del controlador, debemos crear un archivo dentro de ese subdirectorio. Como nuestra función se llama hola(), crearemos el archivo hola.php dentro de app/views/saludo, que de momento sólo contendrá lo siguiente:

<h1>Hola TuTuitero!<h1>

Ahora vamos a http://localhost/tutuitero/saludo/hola y veremos nuestro saludo funcionando. Hemos creado nuestra primera página con kumbiaPHP. 30min? yo creo que menos! :)

Nótese que en nuestra vista sólo hemos definido un texto dentro de etiquetas H1, sin embargo la página tiene un header, un footer, un estilo de letras, un formato. Esto es debido al versátil sistema de plantillas implementado en kumbia, en el cual nos centraremos en un momento.


Hasta este punto, este es el primer post del blog en el que no he mencionado la palabra twitter. Es el momento de hacerlo, aunque sea sólo para recordar el objetivo principal que llevamos desde el principio: crear una herramienta de conexión para twitter que podamos adaptar a nuestras necesidades.

Para cubrir este objetivo, necesitamos un portal web, que podamos navegar fácilmente y que nos permita realizar actualizaciones/consultas mediante una cuenta twitter. Es por ello que hemos introducido kumbiaPHP. Vamos ahora a construir nuestro primer portal web.


Nuestro portal

Ya he dicho que dependiendo de lo que vayamos a construir, vamos a necesitar un sitio más o menos elaborado. Como siempre, podemos partir desde cero y realizar todo el diseño y funcionalidad de nuestro sitio, pero como el objetivo no es hacer un curso sobre diseño web, me iré por el camino más fácil.

Haciendo uso de las bondades que proveen las arquitecturas MVC, separando el diseño (Vista) de las capas funcionales y de control, y aprovechando la gran cantidad de plantillas web que se pueden conseguir gratuitamente por la red, voy a utilizar una de estas (que luego puede ser fácilmente sustituida), de manera de poder centrarme en la funcionalidad del sitio.

Entre los muchos sitios webs que ofrecen plantillas gratis, me gusta mucho opendesigns.org, tienen cientos de plantillas y es simple de navegar. Escogemos alguna de las plantillas que ofrezca, repito, de acuerdo a nuestras necesidades y la descargamos. Yo me he bajado esta:

Descomprimimos el archivo y vamos a encontrar un index.html, un style.css y un directorio de imágenes. Ahora veremos como incrustar estos archivos dentro de nuestro sitio en kumbiaPHP.


Agregando una plantilla a nuestro sitio hecho con kumbiaPHP

Nos centraremos ahora en el contenido del directorio app/views. Vemos los siguientes subdirectorios: errors, pages, partials y templates (además de nuestro directorio saludo). error y pages no nos interesan (de momento), los que nos importan son partials y templates.

Dentro de partials podemos almacenar como su nombre lo indica códigos parciales que podemos incrustar en diferentes vistas, por ejemplo, el footer de nuestro site. Dentro de templates, podemos almacenar la plantilla que queremos que aplique sobre todas las vista de un controlador; no es necesario crear estos templates, y si no lo hacemos, kumbiaPHP tomará la plantilla por defecto (default.phtml).

Si tenemos varias plantillas, desde la capa de control, podemos escoger cual plantilla utilizar, simplemente con incluir la variable template dentro de la clase:

public $template = 'plantilla';

Hagamos una prueba rápida: vamos a sustituir el contenido del archivo default.phtml por el contenido del archivo index.html que viene con nuestra plantilla. Volvamos a abrir en el navegador saludo y veremos que aparece el texto de nuestra plantilla, pero muy mal formateado. Esto es debido a que no tenemos las hojas de estilo ni las imágenes, lógicamente.

Abrimos el directorio app/public y encontraremos algunos subdirectorios. Intuitivamente sabremos que debemos almacenar nuestras imagenes en el directorio img y nuestras hojas de estilo en el directorio css. Todo esto es configurable, si deseas cambiarlo, debes revisar un poco la documentación de kumbiaPHP. Guardamos el archivo style.css que vino con nuestra plantilla dentro de css, y todas las imagenes en el directorio img.

Ahora nos iremos a default.phtml y sustituiremos la línea 12 (el llamado a la hoja de estilo) por la forma en la que se debe invocar desde kumbiaPHP:
<?php echo stylesheet_link_tag('style'); ?>

Justo después colocamos la siguiente línea:
<?php echo stylesheet_link_tags(); ?>

Si volvemos a recargar la página, veremos que ahora ya ha tomado nuestro estilo, pero le hacen falta las imágenes. La forma de especificar las imágenes es como sigue:
<?php echo img_tag('imagen.jpg','id: id_de_imagen','alt: texto alternativo'); ?>

Recorremos el texto y sustituimos de acuerdo al formato mostrado. Adicionalmente, debemos sustituir en el archivo style.css todas las referencias a imagenes del tipo "images/imagen.jpg" a "../img/imagen.jpg". Con estos cambios, tendremos nuestra página exactamente igual a como se ve el demo online en opendesigns.org.

¿Desapareció el "Hola Twitter"?

Observemos que tanto si visitamos http://localhost/tutuitero/saludo/hola o http://localhost/tutuitero vamos a ver lo mismo. Pareciera que hemos perdido el "Hola Twitter en saludo/hola". Recordemos que estamos utilizando una plantilla que será común para todas las páginas del sitio, y que esa plantilla la hemos rellenado con código html, es decir código estático, no le hemos dicho donde queremos que se muestre el contenido particular de cada página. Esto se hace con la función View::content() de kumbia, la cual incluiremos en el lugar que consideremos apropiado.

En este caso, parece lógico colocar el "Hola Twitter" en el cuerpo de nuestra plantilla, por lo tanto justo después de que comienza el div "rightcolumn", colocaremos un div en donde mostrar nuestro mensaje. Quedaría así:

<div class="textboxright">
<?php View::content(); ?>
</div>

Ahora sí notaremos la diferencia entre abrir la página principal o abrir nuestro saludo.

Con esta pequeña introducción es suficiente para comenzar a experimentar con kumbia. Es necesario revisar la documentación del framework para poder explotar todas las bondades que ofrece. Luego mostraré un ejemplo más elaborado, en el que intercambio datos entre las capas de vista y controlador, y además hago uso de las facilidades que ofrece kumbia para la implementación de vistas. Por ahora, es todo.


jueves, 15 de julio de 2010

Nuevo comienzo


Como expliqué en la entrada anterior, pecl/oauth es de momento infactible bajo Windows, y twitteroauth me parece que se queda corta para lo que quiero. Así que salí a la red en búsqueda de otra biblioteca que haga la conexión con twitter sencilla, pero que a la vez nos ofrezca buenas prestaciones.

Es así como llegué al blog de Tijs Verkoyen, quien ha especificado una clase que el ha llamado Twitter Class, utilizando OAuth y cURL (igual que twitteroauth), en la que implementa una gran cantidad de funciones que nos facilitarán enormemente el trabajo. He realizado unas pequeñas pruebas y va de maravillas.

Lógicamente, lo primero que debemos hacer es decargar la librería desde el sitio oficial:
La colocamos en un nuevo directorio (dentro del directorio web de nuestro servidor) y podemos comenzar a utilizarla. Yo voy a copiar en el nuevo directorio, 2 archivos de la entrada anterior: config.php y tutuitero.css. Ahora lo que voy a hacer es escribir un archivo update.php, que haga exactamente lo que hacía el update.php visto anteriormente, pero utilizando la nueva biblioteca:

<?php
session_start
();

require_once(
'twitter.php');
require_once(
'config.php');

// create instance
$twitter = new Twitter(CONSUMER_KEY, CONSUMER_SECRET);

/* Si no tengo tokens de acceso */
if (empty($_SESSION['oauth_token']) || empty($_SESSION['oauth_token_secret']))
{
// get a request token
$twitter->oAuthRequestToken('http://localhost/tutuitero2/twitter-test.php');

// authorize
if(!isset($_GET['oauth_token'])) $twitter->oAuthAuthorize();

// get tokens
$token = $twitter->oAuthAccessToken($_GET['oauth_token'], $_GET['oauth_verifier']);

$_SESSION['oauth_token'] = $token['oauth_token'];
$_SESSION['oauth_token_secret'] = $token['oauth_token_secret'];

}
else
{
$token['oauth_token'] = $_SESSION['oauth_token'];
$token['oauth_token_secret'] = $_SESSION['oauth_token_secret'];
}

// set tokens
$twitter->setOAuthToken($token['oauth_token']);
$twitter->setOAuthTokenSecret($token['oauth_token_secret']);

if(isset($_POST['twitter_msg']))
{
$twitter_message = $_POST['twitter_msg'];
if(
strlen($twitter_message)<1)
{
$error = 1;
}
else
{
$twitter->statusesUpdate($twitter_message);
}
}

?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Send a message to Twitter using PHP</title>
<link rel="stylesheet" type="text/css" href="tutuitero.css" />
</head>

<body>
<h2>Post a message on Twitter</h2>
<p>This page use Twitter API to send an message</p>

<?php if(isset($_POST['twitter_msg']) && !isset($error)){?>
<div class="msg"><?php echo $twitter_status ?></div>
<?php } else if(isset($error)){?>
<div class="msg">Error: please insert a message!</div>
<?php }?>
<p><strong>What are you doing?</strong></p>
<form action="update.php" method="post">
<input name="twitter_msg" type="text" id="twitter_msg" size="40" maxlength="140" />
<input type="submit" name="button" id="button" value="post" />
</form>

<div class="footer">
Visita <a href="http://tutuitero.blogspot.com">tutuitero.blogspot.com</a>
<br />
</div>

</body>
</html>

El código es bastante explícito, no hace falta mayor explicación. En el sitio oficial, se puede encontrar documentación de todos los métodos de la clase. Esta es la biblioteca que utilizaremos de ahora en adelante en tuTuitero.

Acerca de pecl/oauth


En primer lugar, pido disculpas porque han pasado muchos días desde mi última entrada. El trabajo y los estudios me han mantenido alejado de este pequeño proyecto.

En las entradas anteriores he comentado que para conectarme a twitter he revisado dos bibliotecas que servían de 'wrapper' entre twitter y nuestras aplicaciones PHP: pecl/oauth y twitteroauth. Recordemos que nos decidimos por la segunda opción (a pesar de parecer menos completa) debido a que estoy trabajando sobre Windows y no había logrado instalar la primera.

Hoy estuve revisando un poco más acerca de pecl/oauth, y confirmo que bajo linux, parece ser muy sencillo de instalar. De igual forma, los usuarios de Windows la tenemos un poco complicado. De momento, las únicas dos formas de instalar extensiones pecl es:
  1. Teniendo un compilado (.dll) de la extensión. Sería la opción más sencilla, puesto que sólo sería necesario colocar el archivo correspondiente en el directorio de extensiones de php, y colocar la linea correspondiente en el php.ini (extension=php_extname.dll). Existía un sitio que almacenaba los dll de las extensiones pecl, pero desafortunadamente tiene mucho tiempo offline. Tampoco existe un dll oficial que podamos descargar, así que descartada esta opción.
  2. Compilando nuestra propia extensión a partir del código fuente. He encontrado este tutorial paso a paso sobre como realizar el proceso, pero por falta de tiempo no me embarcaré en ella.
Estas son las opciones que tiene en general un usuario de windows para utilizar cualquier extensión pecl. La primera no nos sirve y la segunda es infactible por cuestiones de tiempo, así que hasta que no exista un dll oficial de pecl/oauth no realizaré ninguna prueba con esta biblioteca (lamentablemente).

Sin embargo, he estado haciendo algunas pruebas adicionales con twitteroauth, y no he quedado del todo conforme, así que me he puesto a buscar otras opciones y encontré una nueva librería, de la cual hablaré en el siguiente post.

No existe mucha documentación acerca de pecl en la red, por lo que espero haber aclarado un poco las ideas.