Angelorum

Zend Framework 5: El Modelo de datos

2010-09-14T17:04:00.000-07:00

Esta es la quinta parte de mi tutorial de Zend. La parte anterior la puedes hallar aquí.

Hasta ahora hemos mostrado cómo crear un controlador y sus respectivas acciones, que no son nada más que crear una clase en PHP y agregarle funciones. Pero que esto debe ser hecho usando la línea de comandos (zf.bat ó zf.sh) para que también se agreguen los datos al archivo xml de configuración del proyecto.

Ahora lidiaremos con la parte del Modelo, es decir, con el acceso a bases de datos.

Para los siguientes artículos de este tutorial desarrollaremos un pequeño sistema para guardar datos de álbumes de música, artistas y temas. Usaremos una base de datos Mysql. Asumo que tú, esmerado estudiante, posees conocimientos de SQL y sabes cómo crear una base de datos en MySql, crear usuarios y darles privilegios.

Recomiendo usar Mysql GUI Tools. Es una heramienta que permite administrar bases de datos MySql. Fue creada por MySql, tiene una bonita interfaz gráfica y es gratis. Descárgala desde aquí.

Creando la base de datos

Este es el script de la base de datos que procederemos a crear:

-- MySQL Administrator dump 1.4
--
-- ------------------------------------------------------
-- Server version    5.0.45-community-nt


/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;


--
-- Create schema albums
--

CREATE DATABASE IF NOT EXISTS albums;
USE albums;

--
-- Definition of table `album`
--

DROP TABLE IF EXISTS `album`;
CREATE TABLE `album` (
  `id` int(11) NOT NULL auto_increment,
  `artista_id` int(11) default NULL,
  `nombre` varchar(50) default NULL,
  `fecha` date default NULL,
  `descripcion` varchar(100) default NULL,
  PRIMARY KEY  (`id`),
  KEY `fk_relationship_1` (`artista_id`),
  CONSTRAINT `fk_relationship_1` FOREIGN KEY (`artista_id`) REFERENCES `artista` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `album`
--

/*!40000 ALTER TABLE `album` DISABLE KEYS */;
INSERT INTO `album` (`id`,`artista_id`,`nombre`,`fecha`,`descripcion`) VALUES 
 (1,1,'nos sobran los motivos','2000-09-10','grabacion en vivo'),
 (2,1,'de juez y parte','1995-09-10','album'),
 (3,1,'estaboca es mia','1993-09-10','album muy bueno');
/*!40000 ALTER TABLE `album` ENABLE KEYS */;


--
-- Definition of table `artista`
--

DROP TABLE IF EXISTS `artista`;
CREATE TABLE `artista` (
  `id` int(11) NOT NULL auto_increment,
  `nombre` varchar(50) NOT NULL,
  `descripcion` varchar(100) default NULL,
  `email` varchar(100) default NULL,
  `fecha_ingreso` datetime default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `artista`
--

/*!40000 ALTER TABLE `artista` DISABLE KEYS */;
INSERT INTO `artista` (`id`,`nombre`,`descripcion`,`email`,`fecha_ingreso`) VALUES 
 (1,'joaquin sabina','trobador español','joaquin@sabina.es','2010-10-22 00:00:00'),
 (2,'bruce dickinson','rockero ingles','bruce@hell.net','2010-10-22 00:00:00'),
 (3,'yann tiernsen','compositor frances','yann@france.net','2009-01-01 00:00:00');
/*!40000 ALTER TABLE `artista` ENABLE KEYS */;


--
-- Definition of table `temas`
--

DROP TABLE IF EXISTS `temas`;
CREATE TABLE `temas` (
  `id` int(11) NOT NULL auto_increment,
  `album_id` int(11) default NULL,
  `titulo` varchar(50) NOT NULL,
  `duracion` time default NULL,
  PRIMARY KEY  (`id`),
  KEY `fk_relationship_2` (`album_id`),
  CONSTRAINT `fk_relationship_2` FOREIGN KEY (`album_id`) REFERENCES `album` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `temas`
--

/*!40000 ALTER TABLE `temas` DISABLE KEYS */;
INSERT INTO `temas` (`id`,`album_id`,`titulo`,`duracion`) VALUES 
 (1,3,'esta noche contigo','00:05:00'),
 (2,3,'por el boulevard de los sueños rotos','00:07:00'),
 (3,3,'más de cien mentiras','00:08:00'),
 (4,3,'mujeres fatal','00:04:00'),
 (5,3,'besos con sal','00:03:30');
/*!40000 ALTER TABLE `temas` ENABLE KEYS */;




/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;

Ahora, crearemos un usuario MySQL que tenga privilegios de insert, update, delete y select sobre la base de datos albums (si no sabes cómo hacer esto, puedes usar al usuario root si quieres, aunque no es recomendable hacer eso en un ambiente de desarrollo serio)

Crearemos al usuario albumusuario, clave: 123
Bien, ya estamos listos para empezar a trabajar con la base de datos.

Conectando la base de datos con el proyecto en ZF

Primero, abramos al archivo /application/configs/application.ini y agreguemos lo siguiente (las nuevas líneas están destacadas):

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 0

resources.db.adapter = PDO_MYSQL
resources.db.params.host = localhost
resources.db.params.username = albumusuario
resources.db.params.password = 123
resources.db.params.dbname = albums

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
resources.frontController.params.displayExceptions = 1

Nota: para que esto funcione, php debe tener habilitado el adaptador PDO_MYSQL. Debes asegurarte de que sea así. En Xampp viene habilitado por defecto, pero puede que en tu instalación no sea así.

Para habilitarlo, debes abrir php.ini y asegurarte de que

extension=pdo_mysql

esté descomentado, y reiniciar apache.

Para qué hacemos esto en el archivo applicacion.ini? Pues porque al iniciarse ZF, se conectará a la base de datos usando los parámetros de resources.db. ZF creará por sí mismo la cadena de conección, dependiendo del adaptador que estemos usando. Una vez colocadas estas líneas, podemos empezar a hacer consultas a la base de datos sin preocuparnos.

Creando las clases del Modelo

Ahora crearemos las clases PHP que representarán a las tablas de la base de datos. Esto es muy sencillo.

Tipeamos Alt+Z para ejecutar un comando de Zend desde Netbeans, escribimos 'tabl' en el filtro y seleccionamos el comando
create db-table

y en Parámeteros escribimos: album album (nombre_clase nombre_tabla_referenciada)

Observamos que se ha creado una nueva clase en
/applications/models/DbTable/Album.php :

class Application_Model_DbTable_Album extends Zend_Db_Table_Abstract
{

    protected $_name = 'album';
}

Esta clase representa a la tabla album de la base de datos, como lo indica la variable protected $_name.

Hagamos los mismo con las otras dos tablas:
Alt+z y seleccionamos el comando
create db-table

y en Parámeteros escribimos: artista artista (nombre_clase nombre_tabla_referenciada)

Alt+z y seleccionamos el comando
create db-table

y en Parámeteros escribimos: temas temas(nombre_clase nombre_tabla_referenciada)

Ahora deberíamos tener tres clases en la carpeta /applications/models/DbTable :
Album.php
Artista.php
Tema.php

Pero ¿Cómo las usamos? Ahora lo veremos

Usando las clases del Modelo

Ahora vamos a agregar algo de código en las clases del Modelo de datos.

Abre /applications/models/DbTable/Album.php y reemplaza su contenido con

class Application_Model_DbTable_Album extends Zend_Db_Table_Abstract {

    //nombre de la tabla de la db a la que hace referencia
    protected $_name = 'album';

    /**
     * devuelve un arreglo con los datos del album con id=$id
     * @param  $id id del album
     * @return  arreblo asociativo
     */
    public function get($id)
    {
        $id = (int) $id;
        //$this->fetchRow devuelve fila donde id = $id
        $row = $this->fetchRow('id = ' . $id);
        if (!$row)
        {
            throw new Exception("Could not find row $id");
        }
        //formateo fecha a dia-mes-año para que se vea mejor
        $fecha = $row->fecha;
        $fecha = date("d-m-Y", strtotime($fecha));
//        die($fecha);
        $row->fecha = $fecha;
        return $row->toArray();
    }

    /**
     *  agrega un nuevo album a la base de datos
     * @param  $artista_id
     * @param  $nombre
     * @param  $fecha fehca de registro de este album en la base de datos
     * @param  $descripcion
     */
    public function agregar($artista_id, $nombre, $fecha, $descripcion)
    {
        $data = array('artista_id' => $artista_id, 'nombre' => $nombre,
            'fecha' => $fecha, 'descripcion' => $descripcion);
        //$this->insert inserta nuevo album
        $this->insert($data);
    }

    /**
     * modifica los datos del album id= $id
     * @param  $id
     * @param  $artista_id
     * @param  $nombre
     * @param  $descripcion
     */
    public function cambiar($id, $artista_id, $nombre, $fecha, $descripcion)
    {
        $data = array('artista_id' => $artista_id, 'nombre' => $nombre,
            'fecha' => $fecha, 'descripcion' => $descripcion);
        //$this->update cambia datos de album con id= $id
        $this->update($data, 'id = ' . (int) $id);
    }

    /**
     * borra el album con id= $id
     * @param  $id
     */
    public function borrar($id)
    {
        //$this->delete borrar album donde id=$id
        $this->delete('id =' . (int) $id);
    }

    public function listar()
    {
        //devuelve todos los registros de la tabla
        return $this->fetchAll();
    }
}

Examina el código con cuidado. Le he agregado a la clase los métidos para agregar, modificar, listar y eliminar registros. Como puedes ver, no se ocupan instrucciones SQL en ninguna parte.

En forma resumida, para manipular una tabla usamos las siguientes funciones:

$row = $this->fetchRow('id = ' . $id);
devuelve un objeto con los datos del registro de id = $id

$this->insert($data);
inserta un nuevo registro en la tabla. $data es un array asociativo con el formato array( 'nombre_campo'=>'valor', 'nombre_campo2'=>'valor2', ...);

$this->update($data, 'id = ' . (int) $id);
actualiza el registro con el id = $id. $data es un aray asociativo, al igual que al llamar a $this->insert();

$this->delete('id =' . (int) $id);
borra el registro cuya id = $id.

return $this->fetchAll();
devuelve todos los registros de la base de datos. Puede recibir un parámetro para indicar filtro, orden o paginación.

El código para la clase /applications/models/DbTable/Artista.php sería:

class Application_Model_DbTable_Artista extends Zend_Db_Table_Abstract {

    protected $_name = 'artista';

    /**
     * devuelve un arreglo con los datos del artista con id=$id
     * @param  $id id del artista
     * @return  arreglo asociativo
     */
    public function get($id)
    {
        $id = (int) $id;
        //$this->fetchRow devuelve fila donde id = $id
        $row = $this->fetchRow('id = ' . $id);
        if (!$row)
        {
            throw new Exception("Could not find row $id");
        }
        $fecha = $row->fecha_ingreso;
        $fecha = date("d-m-Y", strtotime($fecha));
//        die($fecha);
        $row->fecha_ingreso = $fecha;
        return $row->toArray();
    }

    /**
     *  agrega un nuevo artista a la base de datos
     */
    public function agregar($nombre,  $descripcion, $email, $fecha_ingreso)
    {
        $data = array('nombre' => $nombre,
            'descripcion' => $descripcion, 'email' => $email,
             'fecha_ingreso'=>$fecha_ingreso );
        //$this->insert inserta nuevo artista
        $this->insert($data);
    }

    /**
     * modifica los datos del artista id= $id
     */
    public function cambiar($id,$nombre,  $descripcion, $email, $fecha_ingreso)
    {
         $data = array('nombre' => $nombre,
            'descripcion' => $descripcion, 'email' => $email,
             'fecha_ingreso'=>$fecha_ingreso );
        //$this->update cambia datos de artista con id= $id
        $this->update($data, 'id = ' . (int) $id);
    }

    /**
     * borra el artista con id= $id
     * @param  $id
     */
    public function borrar($id)
    {
        //$this->delete borrar artista donde id=$id
        $this->delete('id =' . (int) $id);
    }
     public function listar()
    {
         //devuelve todos los registros de la tabla
         return $this->fetchAll();
    }

}

Y el código para El código para la clase /applications/models/DbTable/Temas.php sería:

class Application_Model_DbTable_Temas extends Zend_Db_Table_Abstract {

    protected $_name = 'temas';

    /**
     * devuelve un arreglo con los datos del tema con id=$id
     * @param  $id id del tema
     * @return  arreglo asociativo
     */
    public function get($id)
    {
        $id = (int) $id;
        //$this->fetchRow devuelve fila donde id = $id
        $row = $this->fetchRow('id = ' . $id);
        if (!$row)
        {
            throw new Exception("Could not find row $id");
        }
        return $row->toArray();
    }

    /**
     *  agrega un nuevo tema a la base de datos
     */
    public function agregar($album_id, $titulo, $duracion)
    {
        $data = array('album_id' => $album_id,
            'titulo' => $titulo, 'duracion' => $duracion);
        //$this->insert inserta nuevo tema
        $this->insert($data);
    }

    /**
     * modifica los datos del tema id= $id
     */
    public function cambiar($id, $album_id, $titulo, $duracion)
    {
        $data = array('album_id' => $album_id,
            'titulo' => $titulo, 'duracion' => $duracion);
        //$this->update cambia datos de tema con id= $id
        $this->update($data, 'id = ' . (int) $id);
    }

    /**
     * borra el tema con id= $id
     * @param  $id
     */
    public function borrar($id)
    {
        //$this->delete borrar tema donde id=$id
        $this->delete('id =' . (int) $id);
    }

    public function listar()
    {
        //devuelve todos los registros de la tabla
        return $this->fetchAll();
    }

}

Bien, nuestras clases del Modelo están listas para usarse.
Ahora, el soçiguiente paso es trabajar con las acciones y las vistas, y es lo que haremos en el siguiente artículo.

Zend Framework 4: Controladores y acciones

2010-09-13T16:02:00.000-07:00

Este artículo es parte de mi tutorial de Zend Framework, y es la continuación de la parte 3.

Creando nuevas acciones

Ahora, como creamos una nueva accion en nuestro controlador index? Pues simple, se hace con un comando usando el zf.bat. Pero lo podemos hacer desde el mismo IDE.
Primero, le vamos a asignar a los comandos de ZF un hotkey para poder ejecutarlos más rápido.
Vamos en el menú a Herramientas/Opciones a la pestaña Keymap (o mapeo de teclas o como aparezcan en español), y teclea en Buscar 'zend' (sin las comillas)
Clic en la segunda columna, presiona la tecla Alt y la tecla z (Alt+Z) y Enter. Guarda los cambios.

Ahora, si presionamos Alt+z en la ventana principal del IDE, aparecerá

ese es el listado de todos los comandos de zend.bat disponibles. Para usarlos, hacemos clic en uno de ellos, colocamos en Parámetros los datos requeridos y presionamos el botón Run (ejecutar) o enter.

Para crear una nueva acción

Crearemos una nueva acción en mi controlador index.
Presionemos Alt+z para ejecutar un comando de ZF. Cuando se abra la ventana, en filtro escribamos 'act' sin comillas, seleccionamos el comando create action y escribimos
'prueba index' y presionamos enter. (esto llama al comando zf create action prueba index)

como se ve en la imagen:

Si vemos nuestro archivo
/application/controllers/IndexController.php

veremos que ahora contiene

class IndexController extends Zend_Controller_Action
{

    public function init()
    {
        /* Initialize action controller here */
    }

    public function indexAction()
    {
        // action body
    }

    public function pruebaAction()
    {
        // action body
    }
}

Y también veremos que se ha creado un archivo llamado prueba.phtml en
/application/views/scripts/index/prueba.phtml

Nota: como podemos ver, las paginas .phtml se guardan en
/application/views/scripts/nombre_controlador/nombre_accion.phtml

Abramos el archivo
/application/views/scripts/index/prueba.phtml

borra su contenido y escribe

<h1>Estoy en la vista de la accion prueba()</h1>

Ahora, abriremos esa página por el navegador
recordemos que la forma de abrirla es

http://localhost/miproyecto/public/nombrecontrolador/nombreaccion

en este caso, seria
http://localhost/miproyecto/public/index/prueba

veamos cómo quedó:

ahora, cómo agregamos un nuevo controlador?

Agregando un nuevo controlador

Presionemos Alt+z para ejecutar un comando de ZF. Cuando se abra la ventana, en filtro escribamos 'cont' sin comillas, seleecionamos el comando create controller y escribamos
'micontrolador' y presionamos enter. (esto llama al comando zf create controller micontrolador)

como se ve en la imagen:

Ahora, su revisamos la carpeta de los controladores,
/application/controllers/
veremos que se ha agregado el archivo MicontroladorController.php con la acción index():

class MicontroladorController extends Zend_Controller_Action
{

    public function init()
    {
        /* Initialize action controller here */
    }

    public function indexAction()
    {
        // action body
    }
}

Y si vamos a donde se guardan los archivos .phtml, veremos que se ha agregado una nueva carpeta con el nombre del controlador, y un nuevo archivo en
/application/views/scripts/micontrolador/index.phtml

Ahora, apuntemos el navegador a nuesto nuevo controlador:
http://localhost/miproyecto/public/micontrolador
ó
http://localhost/miproyecto/public/micontrolador/index

veremos esto:

Ahora mostraremos como pasar datos desde la accion a la vista, es decir, desde la funcion index() de Micontrolador al archivo /application/views/scripts/micontrolador/index.phtml:

Vamos al archivo MicontroladorController.php y modificaremos algunas cosas:

class MicontroladorController extends Zend_Controller_Action
{

    public function init()
    {
       //creamos un objeto vista, para pasarle los datos
    //al archivo .phtml en cada accion 
      $this->initView();
        $this->view->baseUrl = $this->_request->getBaseUrl();
    }

    public function indexAction()
    {
        //creo una variable llamada saludo en el objeto vista
        //y le asigno un string
        $this->view->saludo = "hola a todos!!";
    }
}

Ahora, haremos unas modificaciones en la vista, es decir, el archivo index.phtml. Podemos buscar el archivo entre las carpetas del proyecto, o hacer clic dentro de la funcion indexAction(), boton derecho, Go to View (ir a la Vista)

esto me traslada inmediatamente a la vista asociada a la accion , en este caso, el archivo /application/views/scripts/micontrolador/index.phtml

Nota: si desde index.phtml haces boton derecho Navigate/Go to Action, te llevará a la acción asociada a la Vista.

Reemplazaremos su contenido por:
<p>Vista index de la accion index() de controlador Mi controlador</p>
<p>Saludo : <strong><?php echo $this->saludo; ?></strong></p>

Ahora, apuntemos el navegador nuevamente al controlador:
http://localhost/miproyecto/public/micontrolador

Como podemos ver, la variable
$this->view->saludo = "hola a todos!!";
que asignamos en la accion se muestra en la vista haciendo
saludo; ?>

Así, cualquier cosa que asignemos a $this->view en la acción puede ser mostrada en la vista.

Te aconsejo practicar creando algunos controladores y acciones y pasando datos desde la acción a la vista usando $this->view, para que vayas soltando la mano.

Zend Framework ofrece muchas otras herramientas para facilitar el desarrollo del sistema. Entre ellas están el manejo sesiones, de privilegios de usuario, de parámetros, y la que veremos en la siguiente parte de este tutorial, el acceso a bases de datos: el Modelo.

Pasemos al siguiente artículo de este tutorial.

Zend Framework 3: Estructura del proyecto

2010-09-13T15:15:00.001-07:00

Este artículo es la tercera parte de mi tutorial de Zend Framework. La segunda parte está acá.

La estructura del proyecto recién creado se ve así:

Un poco confuso ¿no? Mas no colapses aún, intrépido programador, que es sencillo de entender.
Antes de seguir, asegurémonos de que nuestro servidor web está configurado para usar ZF.

Configuración de Apache (mod_rewrite)

Para que ZF funcione, todas las urls deben ser procesadas por el archivo index.php, el cual decidirá qué hacer con ellas. Por ejemplo, si yo escribo
http://localhost/miproyecto/public/
http://localhost/miproyecto/public/algo/otro
http://localhost/miproyecto/public/saludo/hola

todas esas páginas deberían redirigirse a
http://localhost/miproyecto/public/index.php , el cual decidirá qué paginas mostrar, según la url que se le envíe.

Para que esto se pueda hacer, en el archivo de configuración de apache, httpd.conf :
G:\xampp\xampp\apache\conf\httpd.conf

Debemos descomentar esto:
LoadModule rewrite_module modules/mod_rewrite.so

y reiniciar apache.

Ahora, probaremos nuestro proyecto recién creado en el artículo anterior. Debemos inciar Apache ( si estamos usando Xampp, podemos hacerlo desde el Xampp Control Panel)

Una vez que estamos seguros de que mod_rewrite está activado, abramos nuestro navegador favorito y escribamos la direccion:
http://localhost/miproyecto/public/

y veremos esto:

¡ Felicidades!. Nuestro proyecto en ZF está creado con éxito.

Ahora echaremos un vistazo en los archivos, carpetas y el resto de la estructura de ZF.

Como habíamos dicho, esta es la estructura de carpetas del proyecto:

Veamos el archivo index.php, ubicado en la carpeta public

// Define path to application directory
defined('APPLICATION_PATH')
    || define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application'));

// Define application environment
defined('APPLICATION_ENV')
    || define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'production'));

// Ensure library/ is on include_path
set_include_path(implode(PATH_SEPARATOR, array(
    realpath(APPLICATION_PATH . '/../library'),
    get_include_path(),
)));

/** Zend_Application */
require_once 'Zend/Application.php';

// Create application, bootstrap, and run
$application = new Zend_Application(
    APPLICATION_ENV,
    APPLICATION_PATH . '/configs/application.ini'
);
$application->bootstrap()
            ->run();

Lo explicaremos por partes:

// Define path to application directory
defined('APPLICATION_PATH')
    || define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application'));

indica que la carpeta en donde estarán las clases PHP que implementan el modelo MVC estarán dentro de la carpeta /../application

// Define application environment
defined('APPLICATION_ENV')
    || define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ?

getenv('APPLICATION_ENV') : 'production'));

indica que nuestro sistema al funcionar ocupará la configuración guardada en la sección 'production'. Como veremos muy pronto, hay otras secciones más como 'development' y 'testing' que pueden tener otros valores. Por ejemplo, el indicar si se deben mostrar o no los mensajes de error.

// Ensure library/ is on include_path
set_include_path(implode(PATH_SEPARATOR, array(
    realpath(APPLICATION_PATH . '/../library'),
    get_include_path(),

Indica que nuestras clases y librerías de php que coloquemos en la carpeta /../library serán incluidas en el include_path del sistema.

/** Zend_Application */
require_once 'Zend/Application.php';

// Create application, bootstrap, and run
$application = new Zend_Application(
    APPLICATION_ENV,
    APPLICATION_PATH . '/configs/application.ini'
);
$application->bootstrap()
            ->run();

crea un objeto Zend_Application según la configuración indicada en el archivo '/configs/application.ini' y lo echa a correr. Este objeto es el que hace la redireccion de las urls, inicializa las demás clases, las carga, etc.

Ahora examinemos el archivo /configs/application.ini :

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 0

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
resources.frontController.params.displayExceptions = 1

Este archivo permite indicar el valor de algunas variables de entorno del sistema. Como el objeto Zend_Application lee este archivo al iniciarse, podemos modificar algunos valores en este archivo y así ahorrarnos el tocar el código en PHP.

En este archivo tenemos tres secciones (aunque nosotros podriamos agregar más):

[production]
[staging : production] (que hereda todas las variables desde production, y los agrega o modifica)
[testing : production] (que hereda todas las variables desde production, y los agrega o modifica)
[development : production] (que hereda todas las variables desde production, y los agrega o modifica)

Por ejemplo, como development hereda las variables de la sección de producción, esta contendría:

phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 1

Pero a la vez modifica el valor de las variables
phpSettings.display_startup_errors,
phpSettings.display_errors,
resources.frontController.params.displayExceptions

para que muestren los errores. ¿Qué significa esto? Que si estamos corriendo el sistema en ambiente de production no veremos errores de codigo o de coneccion en la pantalla, pero si lo corremos en ambiente de development, veremos el trazado de errores indicando el nombre de la clase en que ocurrió el error, el código que falló, etc.

Ahora, cómo le decimos al sistema en qué ambiente debe funcionar, produciotn, testing o development? Simple, volvamos al archivo index.php en la carpeta public a las líneas 8 y 9:

// Define application environment
defined('APPLICATION_ENV')
    || define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ?

getenv('APPLICATION_ENV') : 'production'));

si cambiáramos production por development, entonces nuestro sistema mostraría los errores y funcionaría con la configuración de development. Esto hace más fácil el desarrollo, pues podemos tener distintas configuraciones para distintos ambientes en una forma sencilla.

También en el archivo application.ini podemos indicar los parámetros de la o las bases de datos a las que deseamos acceder, entre muchas otras cosas. Más de esto después.

Ahora sigamos viendo los demás archivos.

application/Boostrap.php

Este archivo nos sirve para inicializar las clases del modelo MVC y llamar a algunas funciones que queremos que se llamen para todas ellas

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{


}

Como pueden ver no viene con nada, pero nosotros podríamos agregarle un código como este:

protected function _initView() 
{ 
  $view = new Zend_View(); 
  $view->setEncoding('UTF-8'); 
  $view->doctype('XHTML1_STRICT'); 
  $view->headMeta()->appendHttpEquiv( 
                       'Content-Type', 'text/html;charset=utf-8' 
  ); 
  $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper( 
                 'ViewRenderer' 
  ); 
  $viewRenderer->setView($view); 
  return $view; 
}

El cual, dicho en forma simple, indica que todas las paginas creadas en este proyecto serán de codificación XHTML1_STRICT, con conjunto de caracteres utf-8.

Existen muchas otras clases y métodos que se pueden configurar en este archivo, pero como este es un tutorial sencillo, no daremos más ejemplos.

Manejo de Controladores y Vistas

Como dijimos al principio, ZF implementa el modelo MVC, donde las clases del Modelo son las que acceden a las tablas de las bases de datos, las de la Vista son las páginas con HTML y las del Controlador son las que controlan (valga la redundancia) a las dos anteriores.

Dentro de ZF, un Controlador es una Clase y las vistas son creadas por métodos de esta clase, llamados Acciones.
La url indica el controlador y la acción a la que se llama. Por ejemplo, si colocamos en el navegador:

http://localhost/miproyecto/public/album/agregar
entonces en nuestro proyecto deberemos tener una clase controlador llamada Album, que tenga un método llamado agregar, que cree una página web llamada agregar.phtml

http://localhost/miproyecto/public/album/index
entonces en nuestro proyecto deberemos tener una clase controlador llamada Album, que tenga un método llamado index, que cree una página web llamada index.phtml

http://localhost/miproyecto/public/album/borrar
entonces en nuestro proyecto deberemos tener una clase controlador llamada Album, que tenga un método llamado borrar, que cree una página web llamada borrar.phtml

Aquí se muestra el código de la clase mencionada:

class AlbumController extends Zend_Controller_Action
{

    public function init()
    {
        /* Initialize action controller here */
    }
    //accion agregar
    public function agregarAction()
    {
        // desde aquí coloco datos al archivo 
    // agregar.phtml, que es el que se mostrará al final
    }
    //accion index
    public function indexAction()
    {
         // desde aquí coloco datos al archivo 
    // index.phtml, que es el que se mostrará al final
    }

    //accion borrar
    public function borrarAction()
    {
         // desde aquí coloco datos al archivo 
    // borrar.phtml, que es el que se mostrará al final
    }
}

Al crear un proyecto en ZF se crea automáticamente un controlador llamado Index, con la accion llamada index, que son las que se llaman por defecto, si es que o se indica nombre de controlador ni accion:
Por eso, cuando hacemos

http://localhost/miproyecto/public
http://localhost/miproyecto/public/index
http://localhost/miproyecto/public/index/index
llamamos al controlador index, accion index()

Dónde está la clase controladora index? Podemos verla en
/application/controllers/IndexController.php

Tocas las clases controladoras tienen el nombre de la forma NombreclaseController.php
Si abrimos la clase /application/controllers/IndexController.php, veremos que dentro contiene la función indexAction(), que es la que se llama cuando hacemos
http://localhost/miproyecto/public/index/index

o alguna de las de más arriba

class IndexController extends Zend_Controller_Action
{

    public function init()
    {
        /* Initialize action controller here */
    }

    public function indexAction()
    {
        // action body
    }
}

Ahora, cómo creamos una nueva acción y nuevas clases controladoras? Lee el siguiente artículo.

Zend Framework 2: Crear un proyecto usando Netbeans

2010-09-13T15:12:00.001-07:00

Este artículo es la segunda parte de mi tutorial de Zend Framework 1: Introducción

Breve explicación de qué hace Zend Framework

ZF es , como ya dije, un conjunto de librerías que nos permiten crear sistemas con PHP usando la metodología MVC (Modelo, Vista, Controlador). Pero para que ZF funcione, nuestro sistema web debe estar organizado en una forma especial,. Se deben crear carpetas con nombres específicos, y debemos guardar los archivos PHP que forman la Vista del sistema en cierta carpeta, y los archivos que forman el Modelo en otra carpeta, etc. Además se debe crear un archivo llamado .zfproject.xml en donde se indica un detalle de las clases PHP usadas, qué rol juegan y dónde se ubican.

Menudo lío, ¿verdad? Pero no te desesperes, ya que ZF viene con un intérprete de línea de comandos que hace todo esto por nosotros: zf.bat (ó zf.sh para Linux). Usando este comando podemos crear projectos de ZF que nos crearán toda la estructura de carpetas y el archivo .zfproject.xml con los detalles del proyecto. También lo usaremos para crear el esqueleto de las clases que implementan el modelo MVC, como veremos más adelante.

Instalando nuestro ambiente de Trabajo

Antres de empezar a codificar, lo mejor sería hacernos con un buen IDE para trabajar en PHP. Puedes usar el que más te guste, yo usaré NetBeans 6.9.1 (la version 7.x tambien trae soporte, desde luego). Originalmente este fue pensado como un IDE para trabajar en java, pero tiene extensiones para trabajar en PHP, C/C++ y otros lenguajes. Además, podemos configurarlo para que podamos ejecutar el comando zf.bat directamente desde el IDE (opcional). Netbeans es gratuito, fácil de usar y multilenguaje. Puedes bajarlo desde acá. Si solo lo vas a usar para codificar en PHP, puedes bajarte la versión para PHP, que es más liviana que la que trae soporte para todos los lenguajes.

Instalar Netbeans es fácil. Solo sigue los pasos y listo.

Una vez instalado el IDE, ábrelo y ve a crear un nuevo proyecto (Archivo / Nuevo proyecto)
Selecciona en Categorías PHP y en Proyectos : aplicación PHP y presiona siguiente

Elige miproyecto como nombre para el proyecto, y guardalo en una carpeta DENTRO del directorio para las paginas web del servidor que instalaste. En el caso de Xampp, el directorio es htdocs. Si estas haciendo esto en linux puedes guardarlo en ~/public_html, pero no olvides darte los permisos correspondientes para ESA carpeta (mod rewrite y otras yerbas que iremos explicando más adelante).

Guardaremos nuestro proyecto en la carpeta
C:\xampp\htdocs\miproyecto

presiona Siguiente

aquí veras la url desde la que ejecutaras tu proyecto (podrás cambiarla después, si lo deseas):
http://localhost/miproyecto/

presiona Siguiente

En esta ventana debes indicar si quieres desarrollar este sistema usando algún framework de PHP. Nosotros marcaremos Zend Framework ( ya lo habías imaginado, ¿verdad, aprendiz perspicaz?)

Pero antes de apretar Siguiente, haremos clic en Opciones, ese link azul al lado derecho en la ventana, pues aún no hemos configurado por primera vez nuestro ambiente de desarrollo en PHP

Configurando al ambiente PHP

Esto sólo se hace una vez, así que no te preocupes si te parece algo aburrido. Se trata simplemente de decirle a Netbeans dónde está nuestro zf.bat para que netbeans pueda usarlo para crear los proyectos con ZF, las clases en PHP, etc.

en la ventana que nos aparece ahora, en la pestaña Zend debemos decirle a netbeans en dónde está nuestro archivo zf.bat. Si lo agregamos al PATH de Windows (o de linux) como explicamos más arriba, Netbeans lo encontrará solo. Si no, deberemos indicárselo nosotros mismos.

Ahora, para poder usar zf.bat desde Netbeans, debemos registrar un proveedor de ZF. Para eso, hacemos clic en el botón Register Provider.

Nos mostrará en la ventana principal del IDE un aviso diciendonos que el provider ha sido registrado con éxito.

Nota: si nos sale un aviso que nos dice que no se encuentra archivo de configuración de usuario o algo por el estilo, es que nos olvidamos de ejecutar

zf --setup config-file

desde una consola. Me llevó SEIS dias descubrir eso...

Actualización: si actualizamos Netbeans 6.9 o si tenemos una versión superior, si no hemos ejecutado zf --setup config-file, el ide lo hará por nosotros. Genial, ¿no?

Ahora volvemos a nuestra ventana

y presionamos "siguiente".

Internamente, Netbeans llama al comando

zf create project miproyecto

y con eso se crea toda la estructura de carpetas y archivos que ya habíamos mencionado.

Ahora analizaremos la estructura del proyecto.

Zend Framework 1: Instalación

2010-09-13T14:54:00.002-07:00

Zend Framework (ZF, de ahora en adelante) es un conjunto de librerías que proveen la estructura necesaria para desarrollar un sistema en PHP de forma rápida, eficiente y con un gran ahorro de escritura de código.

Zend Framework nos ayuda a desarrollar aplicaciones usando la metodología MVC: Modelo-Vista-Controlador, la cual divide la estructura de un sistema en tres partes:

Modelo: los archivos (librerías, clases, funciones) relacionados con el acceso a las bases de datos
Vista: los archivos (librerías, clases, funciones) responsables de la presentación de la información al cliente (generalmente, las páginas con contenido HTML)
Controlador: los archivos (librerías, clases, funciones) que sincronizan las dos partes anteriores y que llevan a acabo los procesos del sistema.

Este tutorial consta de las siguientes partes:

Zend Framework 1: Instalacion (el artículo que estás leyendo)
Zend Framework 2: Crear un proyecto usando Netbeans
Zend Framework 3: Estructura del proyecto
Zend Framework 4: Controladores y acciones
Zend Framework 5: El Modelo de datos
Zend Framework 6: Creando las paginas web
Zend Framework 7: Mostrando las paginas web
Zend Framework 8: Creando una plantilla del sistema
Zend Framework 9: Traducir mensajes de error
Zend Framework 10: Trabajando con Ajax
Zend Framework 11: Sesiones, registro, $this->url(), multiples tablas y demases
Zend Framework 12: La importancia de $this->render() y $this->partial() en layout.phtml y las vistas

Descargar el proyecto de ejemplo terminado.

Veamos cómo va esto.

1 Instalación de Zend Framework

Antes de instalar ZF debemos tener un ambiente con un servidor HTTP, PHP y algún motor para base de datos. En este tutorial usaremos Apache, PHP 5 y Mysql 5. Aunque hay muchas formas de instalar estos tres programas, por motivos de simplicidad nosotros los instalaremos usando Xampp. (si estas usando Linux, instala los paquetes correspondientes. Es posible que incluso te permitan instalar automáticamente ZF, como en el caso de OpenSuse 11, que es la distro de linux que uso).

Según la página oficial "XAMPP es una forma fácil de instalar la distribución Apache que contiene MySQL, PHP y Perl. XAMPP es realmente simple de instalar y usar - basta descargarlo, extraerlo y comienzar."

Pueden descargar Xampp desde acá.

Para simplificar las cosas, asumiremos que lo instalamos en
C:\xampp

Una vez instalado nuestro servidor apache y PHP, lo que haremos será descomprimir ZF en alguna carpeta.
Asumiremos que lo descomprimimos en
C:\ZF

Dentro de esa carpeta veremos varias subcarpetas:

bin: contiene el interprete de linea de comandos de ZF
demos
externals
extras contiene, entre otras cosas, librerías adicionales para crear objetos de JQuery desde ZF
incubator
library : contiene las clases en PHP que forman el Zend Framework
resources contiene las traducciones de los mensajes de ZF a varios lenguajes
src
tests

Lo primero que debemos hacer es colocar la ruta donde descomprimimos ZF en la variable include_path en nuestro archivo php.ini. Sin embargo, si descargamos Xampp, nos daremos cuenta de que este ya viene con una versión de ZF pero más antigua. Para simplificar nuestro proceso de instalación, reemplazaremos la carpeta del ZF que viene con Xampp por nuestra versión más moderna de ZF.

Para hacerlo reemplazaremos el contenido de
C:\xampp\php\PEAR\Zend

por el contenido de
C:\ZF \library\Zend

De esta forma, estamos colocando la última versión de ZF en las librerías de nuestro PHP.

Ahora, reemplazaremos estos archivos:

C:\xampp\xampp\php\zf.bat
C:\xampp\xampp\php\zf.php

por

C:\ZF \bin\zf.bat
C:\ZF \bin\zf.php

Ahora, lo último que deberemos hacer es colocar la carpeta C:\xampp\php\ en la variable PATH de Windows, para que nos sea más fácil trabajar con él (más adelante veremos para qué nos servirá).

Una vez hecho esto, comprobaremos si ZF está correctamente instalado. Abrimos una consola de windows (Win+R y escribimos 'cmd' sin comillas) y tecleamos:

zf show version

Debería mostrarnos:
Zend Framework Version: 1.11.10
(que es la versión que yo he instalado)

En caso de que muestre una versión anterior, revisa los pasos anteriores.
En caso de que al escribir zf show version la consola diga

“zf show version no se reconoce como comando interno y externo... bla bla...”

asegúrate de que has incluido en la variable ambiente PATH la ruta donde se encuentra el archivo zf.bat (si estás instalando esto en Linux, obviamente deberías haber incluído el zf.sh, pero esa es harina de otro costal)

Ahora, abramos de nuevo una consola y escribamos:
zf --setup config-file

Esto crea un archivo llamado .zf.ini en nuestro directorio de usuario (en Windows esto es en C:\Documents and Settings\tu_nombre_de_usuario y en Linux es en $HOME) donde guarda algunas preferencias personales para usar ZF como el include_path y la clase CommandProvider, que es necesaria para usar ZF dentro de Netbeans.

¡Y listo, ya tenemos ZF instalado en nuestro computador! Fue fácil, no?

Ahora, ¿cómo crear un proyecto usando ZF ? Lee el siguiente artículo