Updated Apr 05, 2008 by juaxix
Labels:	Featured

Tutorial_02_Crear_un_blog

3.Tutorial zenphp: crear un blog con el framework zenphp

Sección 1

Introducción

¡Bienvenido a zenphp! Seguramente estás viendo este tutorial porque quieres aprender más sobre cómo funciona este framework, asi que relájate y deja que el zen fluya ,aquí y ahora.

Este tutorial te guia a través de la creación de una aplicación simple de bitácora (blog).

Requerimientos:

- Un servidor web. (Apache o IIS) - Un servidor de bases de datos. (mySQL,si es otro debes hacer los cambios oportunos,en la configuración) - Conocimientos básicos de PHP y Programación Orientada a Objetos (incluso Programación Orientada a Aspectos). - Ganas de aprender concentrado :)

¡Vamos allá->Automáticamente!

Sección 2

Descargar zenphp

Primero, vamos a descargar la última versión de zenphp. La versiones estables de zenphp se encuentran en el directorio del SVN llamado "branches",la más recientes pero inestables están en "tags" y el código que se está editando en este momento está en "trunk".

Para descargar se suele utilizar un comando que usa un control de versiones,llamado SVN o "subversion", por ejemplo,para descargar zenphp ,la última versión se utiliza:

svn checkout https://forja.rediris.es/svn/csl2-zenphp/trunk zenphp

Pero si no quieres usar SVN,para descargarla, visita la página del proyecto en ---

Descargar zenphp

Una vez descargado el código, guárdalo dentro del DocumentRoot. La estructura de directorios ha de quedar como sigue:

/ruta_al_document_root
/aplicaciones /zenphp /media .htaccess index.php

Si bajaste la versión de SVN,borra todos los ficheros "svn" ya que no nos hacen falta. ;)

Además puedes borrar el directorio /zenphp/generador/ si crees que no vas a usar el paradigma de la programación orientada a aspectos , este directorio no es necesario en un servidor de producción al igual que el de documentación.

Ahora es un buen momento para conocer cómo funciona la jerarquía de directorios y ficheros de zenphp: revisa el Primer tutorial de aplicaciones donde se explica con más detalle qué contiene cada uno de los directorios.

Sección 3

Crear la base de datos del Blog

Creamos una base de datos con el juego de caracteres UTF-8

  CREATE DATABASE `blog` DEFAULT CHARACTER SET utf8;

si no tenemos permisos en nuestro servidor para crear bases de datos, podemos modificarla con el siguiente código:

ALTER DATABASE `blog` DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

y tabla en dicha base de datos para guardar las entradas con el siguiente código SQL:

Tabla posts:

  CREATE TABLE posts (
      id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
      titulo VARCHAR(150),
      cuerpo TEXT,
      creado DATETIME DEFAULT NULL,
      modificado DATETIME DEFAULT NULL
  );

Insertaremos varias entradas para comprobar su funcionamiento:

  INSERT INTO posts (titulo,cuerpo,creado)
      VALUES ('Primer post', 'Cuerpo del primer post.', NOW());
  INSERT INTO posts (titulo,cuerpo,creado)
      VALUES ('Segundo post', 'Cuerpo del segundo post.', NOW());
  INSERT INTO posts (titulo,cuerpo,creado)
      VALUES ('Tercer post', 'Cuerpo del tercer post', NOW());

El utilizar un ID automático es una idea bastante común ya que permite las tareas de automatización. A la hora de usar las plantillas utilizaremos los mismos nombres de los campos para los componentes de un formulario, etiquetas a reemplazar por el contenido de una tupla, etc.

Sección 4

Creación y configuración de la aplicación por defecto

Ahora vamos a crear una aplicación llamada "blog" y su configuración.

Revisando los directorios que trae zenphp veremos que hay un fichero en aplicaciones/prueba.php ,lo renombraremos por aplicaciones/blog.php y lo abrimos, para renombrar todo "prueba" por "blog" de forma que queda asi:

<?php
/**
 * Aplicacion cliente de blog...
 * @see clase_zen_aplicacion.php , clase_zen.php
 */
class blog extends zen_aplicacion { //zen_aplicacion extiende de zen
 /**
  * Visualizador HTML para la clase
  *
  * @var html_blog
  */
 var $html; 
 /**
  * Constructor
  * @param str $inicializadores clases separadas por comas, a inicializar
  * @return blog
  */
 function blog($inicializadores=""){
  parent::zen_aplicacion($inicializadores);
  $this->html =& new html_blog($this);
 }


}
/**
 * Para mostrar el HTML por pantalla con una plantilla
 *
 */
class html_blog extends zen_html {
 /**
  * Clase plantilla para leer y mostrar HTML
  *
  * @var zen_plantilla
  */
 var $plantilla;
 /**
  * Constructor
  *
  * @param blog $_padre
  * @return html_blog
  */
 function html_blog(&$_padre){
  parent::zen_html($_padre);
  //$this->plantilla =& new zen_plantilla("base_web.html"); //en media/plantillas/es/base_web.html
  //donde 'es' es el idioma por defecto, español
 }
}
?>

Ahora necesitamos modificar /index.php, para que cargue nuestra aplicación blog. Abre index.php y renombra como antes,todo "prueba" por "blog", y quedará asi:

<?php
/**
* ++++++++++++++++++++++++++++++++++++++++++++++
* ++ ===   ===  ||\ || 
* ++ //    =    || \||  
* ++ ===   ===  ||  \| PHP
* ++++++++++++++++++++++++++++++++++++++++++++++
* Aplicacion de blog en aplicaciones/blog.php
* En este ejemplo se carga el sistema en la primera 
* linea y la aplicacion "blog" en la segunda.
* La vista por defecto, es llamada por el enrutador.
* Que ,intenta tomar la plantilla de media/es/base_web.html
* si no existe coge el tema por defecto de zenphp desde
* zenphp/contenido/plantillas/es/base_web.html.
*/
require_once('zenphp/zen.php');
zen___carga_aplicacion('blog');
$aplicacion = new blog();
$aplicacion->enrutador->delegar(); 
?>

El archivo de configuración es tan sencillo de entender que habla por si sólo en aplicaciones/blog.config.php:

  <?php
	//Cada constante lleva "blog_" como prefijo,que es el nombre de la aplicacion
	define('blog_servidor',"localhost"); //servidor de base de datos
	define('blog_usuario' , ""); //usuario de la base de datos
	define('blog_bd',"blog"); //nombre de la base de datos
	define('blog_contrasena',""); //password para la conexion de la base de datos
	define('blog_tipo',"mysql"); //tipo de base de datos
	define('blog_persistente',false); //Conexiones persistentes true o false
	?>

Además podemos abrir /zenphp/zen.php y modificar las constantes siguientes: La URL de nuestro sitio:

define('ZF_SITIO_WEB', 'http://localhost/blog/');

define('ZF_NOMBRE_SITIO', 'Mi primer blog en zenphp');

define('ZF_CORREO_ADMIN', 'admin@correo.es'); //substituir

Una vez hechas estas 3 cosas podemos probar la aplicación y aparecerá algo así:

Lo que significa que zenphp está funcionando con base de datos conectada correctamente.

Sección 5

Acerca de mod_rewrite

Un punto interesante para los buscadores y como gratificación extra es el poder disponer de direcciones simplificadas del tipo http://localhost/blog/entrada/10/ en lugar de http://localhost/blog/index.php/entrada/10/ para tener el primer tipo de direcciones necesitamos modificar nuestro /.htaccess para indicarle las rutas a nuestro servidor Web. Si es Apache,podemos hacer algo como lo siguiente:

AddDefaultCharset UTF-8
Options +FollowSymLinks
RewriteEngine on
RewriteRule ^ruta_ignorada/.* - [PT]
RewriteRule ^entradas /index.php/posts/mostrar_entradas/
RewriteRule ^entrada\/\/([A-Za-z0-9.-]*) /index.php/posts/entrada/$1/
RewriteRule ^\/(.*)\/ /index.php/$1/$2/
RewriteRule ^(.*)\.html /index.php/$1/$2/
RewriteRule ^(.*)\/([A-Za-z0-9.-]*)\.html /index.php/$1/$2/

Veamos que quieren decir estas entradas:

ruta_ignorada es una regla para que no se aplique ninguna de las cadenas del .htaccess.
Si la dirección es http://localhost/blog/entradas/ se redirecciona internamente a index.php/posts/mostrar_entradas/ que

no es otra cosa que una función llamada mostrar_entradas de la clase posts que está vinculada con un puntero a la clase principal de la aplicación blog

Redirige http://localhost/entrada/$titulo)/ a index.php/posts/entrada/($titulo)/ de forma que es la función la que busca el título y devuelve el identificador reconocido y lo muestra en pantalla
El resto lo redigirimos al enrutador.
Se añade la posibilidad de usar los títulos de los posts terminados en HTML para ser redireccionados :)

Sección 6

Crear el Modelo Posts

Para acceder a los datos de los posts que creamos en el paso 1 de la sección 3 necesitamos un modelo de datos que nos lo relacione con la aplicación. Quiero dejar claro, que si quieres a partir de aquí picar tu propio código,estás en tu derecho y tienes toda la libertad del mundo para hacerlo, sólo tienes que crear tu mismo un modelo con new zen_modelo_datos(...) ;) pero veamos como se haría : Las clases modelo de zenphp se pueden colocar donde queramos pero si queremos que los métodos automáticos las carguen sin problemas podemos usar el directorio ideado para ello en /aplicaciones/modelos/posts.php, asi como la vista por defecto (junto con el controlador ya que se llama visualizador en zenphp) en /aplicaciones/vistas/html_posts.php html es el visualizador por defecto definido en /zenphp/zen.php. El contenido del modelo de /aplicaciones/modelos/posts.php es el siguiente:

<?php
class posts extends zen_modelo_datos{
	/**
	* Es la aplicación blog
	* @var blog
	*/
	var $padre;
	/**
	* Es nuestro visualizador
	* @var html_blog
	*/
	var $html;
	/**
	* Nuestro constructor
	* @param blog $blog
	* @return posts
	*/
	function posts (&$blog){
		parent::zen_modelo_datos($blog,"","posts"); 
		//con esto indicamos a zenphp que solo le vamos a decir la tabla y que sea automática 
		// la obtención de los nombres de los campos,i.e., esto==>parent::zen_modelo_datos($blog,"id,titulo,cuerpo,creado,modificado","posts");
	}
}
?>

En zenphp el sistema de padres e hijos es lo que relaciona todo entre si. En un modelo de datos el padre es una aplicación (zen_aplicacion) y en un visualizador el padre es un zen_modelo_datos.

Sección 7

Crear el Controlador de Posts

Como he mencionado en el paso anterior ,el visualizador (controlador+vista: interacción con el usuario) se coloca en /aplicaciones/vistas/html_posts.php ,opcional: si quieres tener tu propio visualizador basta con que lo crees en el constructor del modelo posts con $this->html=& new MiVisualizador($this); A continuación se muestra como se debe ver el visualizador básico:

/aplicaciones/vistas/html_posts.php

<?php
class html_posts extends zen_html_modelo_datos {
	/**
	* El modelo de datos asociado al visualizador
	* @var posts
	*/
	var $padre;
	/**
	* Constructor del visualizador de posts
	* @var posts $posts
	* @return html_posts
	*/
	function html_posts(&$posts){
		parent::zen_html_modelo_datos($posts);
	}
}
?>

Hecho esto,con estos nombres concretos,no hace falta cargar la vista para realizar la instanciación y asociación con el modelo ya que se hace automáticamente por zenphp. De forma que en el constructor del zen_modelo_datos que es "posts" se cargar html_blog.php y se instancia en $blog->posts->html. Para que los mecanismos automáticos tengan toda la información necesaria para cargar todo lo que acabamos de escribir ,basta con añadir una variable a la clase del blog, nuestro modelo posts, justo después de var $html; con el siguiente contenido: /aplicaciones/blog.php

 /**
 * Modelo de datos Posts
 * @var posts
 */
 var $posts;

y decirle a zenphp que si quiere cargar dicho modelo, para ello modificamos /aplicaciones/blog.php,el constructor:

 /**
  * Constructor
  * @param str $inicializadores clases separadas por comas, a inicializar
  * @return blog
  */
 function blog($inicializadores=""){
  parent::zen_aplicacion($inicializadores);
  $this->html =& new html_blog($this);
  zen___importar_modelos($this,"posts");
 }

Ahora, vamos a agregar una acción por defecto en el visualizador de los posts Cuando un usuario solicita localhost/index.php/posts, es lo mismo que solicitar localhost/index.php/posts/index/. Como queremos que nuestros lectores vean una lista de las entradas escritas cuando solicitan ese URL, la acción (función de la clase html_posts asociada al modelo posts) index debe ser algo como lo siguiente: Si queremos comprobar que todo funciona basta con poner echo get_class($this->padre->padre); pero haremos algo más avanzado, añadimos a /aplicaciones/vistas/html_posts.php justo después de la función del constructor llamado html_posts):

función index() del visualizador de posts (agregada la función/acción index)

 	/**
	* Muestra el listado de artículos de posts
	*/
	function index(){
		echo $this->listado("posts/elementos.html","posts/listado.html","elementos");
	}

Listado es una función que toma la plantilla media/es/posts/elementos.html y substituye en ella con sus nombres de campos todas las tuplas y después cambia la etiqueta "elementos" en /media/plantillas/es/posts/listado.html por el listado generado, devolviendo el contenido procesado. Para que esto funcione necesitamos las plantillas: elementos y listado: /media/plantillas/es/posts/elementos.html

<li>
	#id# :: #titulo# ( #creado# )
</li>

/media/plantillas/es/posts/listado.html

<h1>Listado de posts:</h1><br>
<ul>#elementos#</ul>

Al ejecutar esto obtendremos el siguiente resultado (con nuestra fecha cambiada ;) ):

Listado de posts:

    * 1 :: Primer post ( 2008-03-23 17:02:21 )
    * 2 :: Segundo post ( 2008-03-23 17:02:21 )
    * 3 :: Tercer post ( 2008-03-23 17:02:21 )

Déjame explicarle esto un momento. Al definir la función index() dentro de html_posts, los usuarios pueden acceder a la lógica al solicitar localhost/index.php/posts/index/. De manera similar, si se define una función loquesea(), los usuarios podrán acceder a la lógica que define solicitando localhost/index.php/posts/loquesea/.

Podemos añadir filtrados y mejorar la función con lo que sabemos de nuestros datos de una forma sencilla, dentro de la función que acabamos de definir, basta con hacer lo siguiente, justo debajo de "index() {":

 $this->padre->campos = "id,titulo,DATE_FORMAT(creado,'%d/%m/%Y') as creado";

de forma que la salida obtenida es:

Listado de posts:

    * 1 :: Primer post ( 23/03/2008 )
    * 2 :: Segundo post ( 23/03/2008 )
    * 3 :: Tercer post ( 23/03/2008 )

Como siempre en zenphp, hay más formas de hacer una sóla cosa, es para dar libertad al programador que quiere picar su propio código, en este caso podemos definir una función con la que filtrar el contenido que devuelve la consulta, para ello en lugar de lo anterior ,justo después de "index(){" ponemos:

$this->padre->filtros_postprocesamiento = array("creado" => "zen_parsear_fecha_a_normal");

$padre es la variable que nos devuelve el modelo de datos, en PHP todo es secuencial y gracias a zenphp es circular, podemos reutilizar cualquier cosa desde cualquier parte :) De forma que si definimos antes de la consulta un filtro post-procesamiento es para aplicarlo después de consultar los datos y para que se muestre con cada tupla substituyéndolo en las plantillas diseñadas. Es más, hay otra forma de hacer lo mismo, y es :

echo zen_parsear_fecha_a_normal($this->padre->tuplas[0]['creado']);

donde tuplas[0] son los datos de las consultas guardadas en dicho modelo como tuplas. Para ver el modelo de datos ir a /zenphp/clases/clase_zen_modelo_datos.php y para ver funciones a /zenphp/funciones/ Algunas funciones es necesario cargarlas ,para eso está la función zencarga_funciones('nombre'). Por defecto se cargan las del núcleo, las de fechas y las generales, si necesitamos cargar las de ficheros podemos hacer lo siguiente:

<?php
if (!function_exists('zen_guardarFichero'))
 zen___carga_funciones('zen_ficheros');
?>

Sección 8

Probando las vistas de Post y añadiendo Scaffolding (andamio)

Ahora que ya hemos conectado nuestra base de datos con el modelo y que la lógica ha sido definida en el visualizador, ya tenemos la vista y el controlador definidos.

Los visualizadores son una síntesis de las vistas y los controladores que se pueden ver en frameworks como CakePHP,Symfony o Ruby On Rails, son sólo fragmentos de HTML y PHP que cuadran dentro de la diagramación de la aplicación. Las diagramaciones pueden ser cambiadas entre si, al igual que en aquellos.

Podemos ver lo que tiene un modelo de datos posts tras ser consultado en index añadiendo después de

echo $this->listado("posts/elementos.html","posts/listado.html","elementos");

el código:

print_r($this->padre->tuplas); //padre es un modelo de datos posts,estamos en el visualiador html_posts,función index(),al final.

de forma que la función index() queda asi

/aplicaciones/vistas/html_posts.php

	/**
	* Muestra el listado de artículos de posts
	*/
	function index(){
		$this->padre->campos = "id,titulo,creado"; //Reducimos el número de los campos a consultar para mejorar la eficiencia
		$this->padre->filtros_postprocesamiento = array("creado" => "zen_parsear_fecha_a_normal");
		echo $this->listado("posts/elementos.html","posts/listado.html","elementos");
		print_r($this->padre->tuplas);
	}

// Salida generada por print_r($this->padre->tuplas):

Array ( 
 [0] => 
	Array ( 
		[id] => 1 
		[titulo] => Primer post 
		[creado] => 23/03/2008 
	) 
	[1] => 
		Array ( 
		[id] => 2 
		[titulo] => Segundo post 
		[creado] => 23/03/2008 
		) 
	[2] => 
		Array ( 
		[id] => 3 
		[titulo] => Tercer post 
		[creado] => 23/03/2008 
		) 
)

Afortunadamente esto debería ser de cierta manera sencillo de entender...

Ya te habrás dado cuenta de el uso del objeto llamado $html. Esta es la instancia de la clase html_posts (zen_html_modelo_datos), zenphp viene con un conjunto de 'ayudantes' que hacen más fáciles labores como creación de enlaces, formularios, Javascript,Ajax,etc. Puede aprender más sobre su uso en el blog y los foros, pero lo que es realmente importante observar es que el método zen_enlace('título','dirección') generará un enlace HTML con el título (primer parámetro) y URL (segundo parámetro) indicados; aunque esto no es necesario si incluimos en nuestra plantilla por defecto: /media/plantillas/es/base_web.html la etiqueta (antes de

Unknown end tag for </head>

): <base href="#ZF_SITIO_WEB#"> ya que el navegador tomará directamente los enlaces de dicha ruta.

Cuando se escriben URLS en zenphp, se debe indicar una ruta relativa a la base de la aplicación, el framework se encargará de completar el resto, que viene a ser : la etiqueta HTML con el título y ZF_SITIO_WEB que lo definimos en /zenphp/zen.php, dicha función está en /zenphp/funciones/zen_html.php :: (zen_enlace()). De ese modo, las URLs que escribimos son típicamente de la forma controlador/acción/id/.

Añadiendo scaffolding al modelo

Basta con poner una variable en /aplicaciones/modelos/posts.php después de var $padre; con el código:

	/**
	* Permite el uso de scaffolding
	* @var zen_andamio
	*/
	var $andamio;

Ahora puede dirigir su navegador a la dirección http://localhost/blog/index.php/posts/scaffold/ o bien a http://localhost/blog/index.php/posts/andamio/

Debería poder ver el contenido del modelo:

formateado correctamente con un editor de entradas bastante simplificado. Las palabras mágicas que activan la dirección se pueden definir en /zenphp/zen.php en la constante: ZF_PALABRAS_ANDAMIO Para más información, ver el siguiente pdf

Sección 9

Agregando Entradas al blog

Leer desde la base de datos y editar las entradas automáticamente está muy bién, pero ahora debemos permitir que se agreguen nuevasn entradas como cliente, para poder borrar el scaffolding o andamio.

Para empezar necesitamos un formulario con el que escribir una entrada en el blog:, de hecho he cogido la que me genera el andamio directamente, como base para editar: /media/plantillas/es/posts/nuevo.html

<h1>A&ntilde;adir nuevo post</h1><br>
<form name="frmCrear" id="frmCrear" action="index.php/posts/crear/" method="post" enctype="multipart/form-data">
		<label for="titulo">T&iacute;tulo</label><br>
		<input type="text" name="titulo" id="titulo"><br>
		<label for="cuerpo">cuerpo</label><br>
		<textarea name="cuerpo" id="cuerpo"></textarea><br>
		<label for="creado">Creado</label><br>
		<input name="creado" id="creado" value="" type="text"><br>
		<input type="submit" value="Crear"><br>
		<input type="reset" value="Limpiar">
</form>

y ya que estamos, maquetaremos un poco la página para meter el formulario en la plantilla por defecto que se mostrará en todas las demás páginas porque por defecto se toma del directorio de contenido por defecto de zenphp (que está en /zenphp/contenido/plantillas/es/base_web.html) /media/plantillas/es/base_web.html

<html>
<head>
<meta content="text/html; charset=utf-8" http-equiv="content-type"/>
<title>#titulo# #ZF_NOMBRE_SITIO#</title>
<base href="#ZF_SITIO_WEB#"/>
</head>
<body>
#contenido#
</body>
</html>

Para crear el enlace en el listado,hemos cambiado la plantilla /media/plantillas/es/posts/listado.html añadiéndole al final la etiqueta #enlace_nuevo# y al final de la función index() de /aplicaciones/vistas/html_posts.php hemos modificado la línea del echo cambiándola por:

echo $this->listado(
    "posts/elementos.html","posts/listado.html","elementos",
    array("enlace_nuevo"=>zen_enlace('Crear nuevo post','index.php/posts/nuevo/'))
);

o bien lo podiamos haber hecho más simple,si sólo hubiéramos cambiado la plantilla listado.html añadiéndole el enlace a mano:

<a href="index.php/posts/nuevo/">Crear nuevo post</a>

y sin más cambios ....como quiera el programador :)

Entonces lo único que nos queda para mostrar la interfaz de forma automática es asociarla en nuestra acción nuevo() de /aplicaciones/vistas/html_posts.php justo debajo de la función index():

	/**
	* Función más avanzada, carga la plantilla base_web.html al final y coloca en su etiqueta #contenido#	
	* el formulario de creación "posts/nuevo.html" llamando al padre->padre que es la aplicación web,donde está
	* la clase HTML (zen_html) que tiene el método mostrar que reemplaza los valores de configuración por defecto.
	*/
	function nuevo(){
		$p = new zen_plantilla("posts/nuevo.html");
		$this->c['titulo'] = "Nuevo post ";
		$this->c['contenido'] = $p->contenido;
		$this->padre->padre->html->mostrar($this->c);
	}

Ahora ,al enviar el formulario se van a capturar los datos por medio de la acción nuevo ,que no existe por eso la crearemos ,justo debajo de la que acabamos de añadir:

/**
	* Función que inserta una tupla en posts y devuelve el resultado de la operación
	*/
	function crear(){
		$this->c['titulo'] = "Insertando post...";
		$this->padre->filtros_preprocesamiento = array("creado"=>"zen_parsear_fecha_a_mysql");
		$idp = $this->padre->insertar($_REQUEST);
		if ($idp){
		 $this->c['contenido'] = "Se ha insertado correctamente el post ($idp).[<a href='index.php/posts/actualizar/".$idp."/'>editar</a>";
		} else {
		 $this->c['contenido'] = "Ha ocurrido un error con la inserci&oacute;n del nuevo post!<br>";
		}
		$this->c['contenido'] .= '<br><a href="index.php/posts/">continuar</a>';
		$this->padre->padre->html->mostrar($this->c);
	}

Cuando un usuario envía un formulario con datos POST a su aplicación, dicha información estará disponile en $_REQUEST.

Para realizar la actualización repetiremos la operación de esta sección pero modificando "nuevo" por "actualizar" y además necesitamos cargar el ID del artículo, para ello disponemos del parámetro de las acciones,i.e.,de los métodos de nuestros visualizadores por ejemplo, la función nuevo() puede contener si el programador lo necesita, un parámetro $datos que es todo lo que va justo después del nombre de la función "nuevo" en este caso, ejemplo: index.php/posts/nuevo/1/ --> en el método de html_posts.php seria

function nuevo($datos=null) {}

$datos[0] vale 1 o lo que tuviera ;) Veamos como se haría entonces la actualización de datos: /media/plantillas/es/posts/editar.html

<h1>Editar post #id#</h1><br>
<form name="frmEditar" id="frmEditar" action="index.php/posts/actualizado/#id#/" method="post" enctype="multipart/form-data">
		<label for="titulo">T&iacute;tulo</label><br>
		<input type="text" name="titulo" id="titulo" value="#titulo#"><br>
		<label for="cuerpo">cuerpo</label><br>
		<textarea name="cuerpo" id="cuerpo">#cuerpo#</textarea><br>
		<label for="creado">Creado</label><br>
		<input name="creado" id="creado" value="#creado#" type="text"><br>
		<input type="submit" value="Actualizar"><br>
		<input type="reset" value="Limpiar">
</form>

Ahora para que la función (acción) que muestra el formulario de edición sea visible la creamos,junto con la que recibe los datos ambos en el visualizador de posts: /aplicaciones/vistas/html_posts.php

	/**
	* Función más avanzada aún,que carga la plantilla base_web.html al final y coloca en su etiqueta #contenido#,	
	* el formulario de creación "posts/editar.html" llamando al padre->padre que es la aplicación web,donde está
	* la clase HTML (zen_html) que tiene el método mostrar que reemplaza los valores de configuración por defecto.
	* Para pasarle los datos,se cargan del modelo,que es especificdo por el id en $datos[0]
	*/
	function actualizar($datos=null){
		$this->c['titulo'] = "Editar post ";
		$this->padre->condiciones_where = "where id=".intval($datos[0]);
		$this->padre->filtros_postprocesamiento = array("creado"=>"zen_parsear_fecha_a_normal");
		$post = $this->padre->obtener_primero();
		if (!$post) die("No existe el post");
		$this->c['contenido'] = $this->editar("posts/editar.html",$post);
		$this->padre->padre->html->mostrar($this->c);
	}
  /**
	* Función que actualiza una tupla en posts y devuelve el resultado de la operación
	*/
	function actualizado($datos=null){
		$id = intval($datos[0]);
		if (!$id || !$this->padre->existe($id)) die("No existe el post");
		$this->c['titulo'] = "Actualizando post...";
		$this->padre->filtros_preprocesamiento = array("creado"=>"zen_parsear_fecha_a_mysql");
		if ($this->padre->actualizar($_REQUEST)){
		 $this->c['contenido'] = "Se ha actualizado correctamente el post";
		} else {
		 $this->c['contenido'] = "Ha ocurrido un error con la actualizaci&oacute;n del post!<br>";
		}
		$this->c['contenido'] .= '<br><a href="index.php/posts/">continuar</a>';
		$this->padre->padre->html->mostrar($this->c);
	}

sólo resta añadir el enlace en la plantilla de posts /media/plantillas/es/posts/elementos.html

<li>
	#id# :: #titulo# ( #creado# ) <a href="/index.php/posts/actualizar/#id#/">Actualizar</a>
</li>

para que tengamos un listado como este:

Listado de posts:

    * 1 :: Primer post ( 23/03/2008 ) Actualizar
    * 2 :: Segundo post ( 23/03/2008 ) Actualizar
    * 3 :: Tercer post ( 23/03/2008 ) Actualizar
    * 5 :: dasdad ( 00/00/0000 ) Actualizar
    * 6 :: dasdad ( 04/08/2008 ) Actualizar

Crear nuevo postArray ( [0] => Array ( [id] => 1 [titulo] => Primer post [creado] => 23/03/2008 ) [1] => Array ( [id] => 2 [titulo] => Segundo post [creado] => 23/03/2008 ) [2] => Array ( [id] => 3 [titulo] => Tercer post [creado] => 23/03/2008 ) [3] => Array ( [id] => 5 [titulo] => dasdad [creado] => 00/00/0000 ) [4] => Array ( [id] => 6 [titulo] => dasdad [creado] => 04/08/2008 ) )

código fuente generado:

Listado de posts:<ul><li>1 :: Primer post ( 23/03/2008 ) <a href="index.php/posts/actualizar/1/">Actualizar</a></li><li>2 :: Segundo post ( 23/03/2008 ) <a href="index.php/posts/actualizar/2/">Actualizar</a></li><li>3 :: Tercer post ( 23/03/2008 ) <a href="index.php/posts/actualizar/3/">Actualizar</a></li><li>5 :: dasdad ( 00/00/0000 ) <a href="index.php/posts/actualizar/5/">Actualizar</a></li><li>6 :: dasdad ( 04/08/2008 ) <a href="index.php/posts/actualizar/6/">Actualizar</a></li></ul><hr><a href="http://localhost/blog/index.php/posts/nuevo/">Crear nuevo post</a>Array
(
    [0] => Array
        (
            [id] => 1
            [titulo] => Primer post
            [creado] => 23/03/2008
        )

    [1] => Array
        (
            [id] => 2
            [titulo] => Segundo post
            [creado] => 23/03/2008
        )

    [2] => Array
        (
            [id] => 3
            [titulo] => Tercer post
            [creado] => 23/03/2008
        )

    [3] => Array
        (
            [id] => 5
            [titulo] => dasdad
            [creado] => 00/00/0000
        )

    [4] => Array
        (
            [id] => 6
            [titulo] => dasdad
            [creado] => 04/08/2008
        )

)

Sección 10

Validación de Datos

Para validar los datos ,zenphp provee de mecanismos automatizados que validan los datos con javascript y PHP. Para verlo visita el blog

Sección 11

Eliminar Entradas

Para borrar entradas ,simplemente añadimos a la plantilla de media/plantillas/es/elementos.html el enlace {{ Borrar }} y la función al visualizador aplicaciones/vistas/html_posts.php (debajo de la de actualizado()):

	/**
	* Borra un post de la tabla posts y muestra el resultado por pantalla
	*/
	function borrar($datos=null){
		$id = intval($datos[0]);
		if (!$id || !$this->padre->existe($id)) die("No existe el post");
		$this->c['titulo'] = "Borrando post...";
		if ($this->padre->borrar($id)){
		 $this->c['contenido'] = "Se ha borrado correctamente el post $id";
		} else {
		 $this->c['contenido'] = "Ha ocurrido un error con la actualizaci&oacute;n del post $id!<br>";
		}
		$this->c['contenido'] .= '<br><a href="index.php/posts/">continuar</a>';
		$this->padre->padre->html->mostrar($this->c);
	}

Para añadir confirmación puede usarse cualquier técnica en PHP como un parámetro $GET'confirmacion' que se añada a la URL o un diálogo en JavaScript con /zenphp/contenido/js/es/zen_dialogo.js Ver el blog para más información.

Sección 12

Conclusión

Crear aplicaciones de esta manera te dará más paz, tiempo libre, y elegancia. Hay muchas más cosas que se pueden explicar: el generador de aplicaciones, el paradigma POA ,etc.,etc. ¡Sigan atentos a sus pantallas!