Con este plugin cargamos un XML, pasandole unos parámetros de configuración para que automáticamente nos seleccione un nodo especifico del XML. Esta configuración utiliza comodines de Zend_Route (Module, Controller, Action, ParamX….) para el nombre del archivo y el nodo por defecto:

.
 *
 *
 * @category   Cuatroxl
 * @package    Cuatroxl_Zf_Action_Helper
 * @autor      Jimmy Collazos 
 * @license    http://www.gnu.org/licenses/gpl.html     GPLv3
 * @version    0.01
 */

/**
 * @see Zend_Controller_Plugin_Abstract
 */
require_once 'Zend/Controller/Plugin/Abstract.php';

/**
 * @category   Cuatroxl
 * @package    Cuatroxl_Controller
 * @subpackage Cuatroxl_Controller_Plugin
 * @license    http://www.gnu.org/licenses/gpl.html     GPLv3
 */
class Cuatroxl_Controller_Plugin_DataPage extends Zend_Controller_Plugin_Abstract
{

    /*
     * Variable de configuración
     *
     * @var Array
     */
    protected       $_config      = array('autoload'  => false
                            ,'filePath'     => 'public/:module/:controller/:action.xml'
                            ,'xpath'        => ''
                            ,'basePath'     => APPLICATION_PATH
                            // esta opción es solo para cuando NO usamos Zend_Application
                            ,'_keyPlugin'   => '');

    /*
     * Ruta del archivo XML a cargar
     *
     * @var string
     */
    protected       $_filePath = null;

    /*
     * Xpath query para poder obteenr el nodo por defecto del XML
     *
     * @var string
     */
    protected       $_xpath = null;

    /*
     * En esta variable se almacena el XML final con el que podemos trabajar
     * desde el controlador
     *
     * @var SimpleXMLElement
     */
    protected       $_data;

    /*
     * Nombre asignado en el archivo de configuración de al aplicación
     *
     * @var string
     */
    private         $_keyPlugin;

    /**
     * Constructor
     *
     * @param  Array
     * @return void
     */

    public function  __construct( array $options = array() ) {

        $this->_setConfig($options);

    }

    /*
     * routeShutdown() es como el constructor ya que se usa para setear el XML
     * en caso de estar activado el "autoload" y también setea la configuración del INI
     *
     * @param Zend_Controller_Request_Abstract
     * @return void
     */
    public function routeShutdown( Zend_Controller_Request_Abstract $request)
    {

        //@TODO cambiar esto por una funcion que setee todas las opciones
        $bootstrap = Zend_Controller_Front::getInstance()
                            ->getParam('bootstrap');
        if(! empty($bootstrap) ){
            $bootstrapOptions   = $bootstrap->getOptions();
            $this->_keyPlugin          = $this->_getKeyPlugin($bootstrapOptions['resources']['frontController']['plugins']);
            if($this->_keyPlugin){
                if(! empty($bootstrapOptions[$this->_keyPlugin]['config'])){
                    $this->_setConfig($bootstrapOptions[$this->_keyPlugin]['config']);
                }
            }
            //@TODO añadir una excepción
            $this->_parseFilePath();
            $this->_parseXPath();

            if( $this->_config['autoload'] ){
                $this->_loadXmlFile();
                $this->_setXPath();
            }
        }
    }

    /*
     * Setea los daots en la variable _data
     *
     * @param SimpleXMLElement
     * @return void
     */
    public function setData ( SimpleXMLElement $data )
    {
        $this->_data = $data;

        if(!empty ($this->_keyPlugin) ){
            Zend_Controller_Front::getInstance()
                    ->setParam($this->_keyPlugin, $this->_data);
        }
    }

    /*
     * Devueble el XML obtenido
     *
     * @return Cuatroxl_Controller_Plugin_DataPage $_data
     *
     */
    public function getData ()
    {
        return $this->_data;
    }

    /*
     * Configura todas las opiones de la clase
     *
     * @var array
     * @return Cuatroxl_Controller_Plugin_DataPage  Provides a fluent interface
     *
     */
    protected function _setConfig( array $config) {
        foreach ($config as $k => $v){
            if(!empty ($v)){
                $this->_config[$k] = $v;
            }
        }
        return $this;
    }

    /*
     * Carga el archivo XML
     *
     * @var string
     * @return Cuatroxl_Controller_Plugin_DataPage Provides a fluent interface
     *
     */
    protected function _loadXmlFile( string $fileName = NULL ) {
        if( $fileName === NULL ){
            $fileName = $this->_filePath;
        }
        if( file_exists( $fileName ) ){
            $data   = simplexml_load_file( $fileName );
            $this->setData( $data );
        }
        return $this;
    }

    /*
     * Ejecuta una query sobre el XML con xpath y devuelve TRUE o FALSE  según el exito de la consulta
     *
     * @var string
     * @return Boolean
     *
     */
    protected function _setXPath( string $path = NULL ) {
        if( $path === NULL){
            $path = $this->_xpath;
        }

        if( empty($this->_xpath) ){
            return false;
        }

        $data = $this->_data->xpath($this->_xpath);

        if( empty ($data[0]) ){
            return false;
        }else{
            $this->setData( array_shift( $data ) );
            return true;
        }

    }

    /*
     * remplaza los comodines en la ruta al XML y devuelve TRUE o FALSE
     * según el exito de la consulta
     *
     * @return Boolean
     *
     */
    private function _parseFilePath() {

        //@TODO indagar para hacer este proceso con con Zend_Controller_Router_Route
        if(! preg_match_all("/:[^\/\.]+/s", $this->_config['filePath'], $matches) ){
            return false;
        }
        $request        = $this->getRequest();
        $values         = array();
        $matches        = $matches[0];
        foreach($matches as $v){
            $values[] = $request->getParam(substr($v, 1));
        }
        $matches[]          = '/';
        $values[]           = DIRECTORY_SEPARATOR;
        $this->_filePath    = str_replace($matches, $values, $this->_config['basePath'].$this->_config['filePath']);

        return true;
    }

    /*
     * remplaza los comodines en la ruta al nodop por defecto del  XML
     * y devuelve TRUE o FALSE  según el exito de la consulta
     *
     * @return Boolean
     *
     */
    private function _parseXPath() {

        //@TODO indagar para hacer este proceso con con Zend_Controller_Router_Route
        if( empty ($this->_config['xpath']) ){
            return false;
        }
        if(! preg_match_all("/:[\d\w_]+/s", $this->_config['xpath'], $matches) ){
            $this->_xpath = $this->_config['xpath'];
            return true;
        }
        $request        = $this->getRequest();
        $values         = array();
        $matches        = $matches[0];
        foreach($matches as $v){
            $values[] = $request->getParam(substr($v, 1));
        }

        $this->_xpath    = str_replace($matches, $values, $this->_config['xpath']);

        return true;
    }

    /*
     * Devuelve el nombre que se designó en el archivo de configuración
     *
     * @return string o false
     */
    private function _getKeyPlugin(array $config)
    {
        foreach ($config as $k => $v){
            if($v === 'Cuatroxl_Controller_Plugin_DataPage'){
                return $k;
            }
        }
        return false;
    }
}

Modo de uso con Zend_Application

Configuracion:

;definimos la clase, en este caso lo asociamos a "dataPage"
resources.frontController.plugins.dataPage = "Cuatroxl_Controller_Plugin_DataPage"
;le decimos que la carga es automática
dataPage.config.autoload = 1
;la ruta del XML utilizando como comodín el parámetro LANG, nombre del controlador y acción
dataPage.config.filePath = ":lang/:controller/:action.xml"
;el nodo, del XML, por defecto que tiene que cargar; también usando la variable PAGE
dataPage.config.xpath = "pages/page[@id=':page']"
;el directorio raíz de donde están los XML
dataPage.config.basePath = APPLICATION_PATH "/../public/data/"

Controller:

public function indexAction()
{
    // El parámetro "dataPage" es el mismo nombre con que vinculamos en el archivo de configuración
    var_dump($this->getFrontController()->getParam('dataPage'));
}

pdt: tengo que subirlo a Google Code; por lo que pronto colgaré la dirección con un manual más sencillo

Estoy haciendo un plugin ( Zend_Controller_Plugin ) y hay una variable que necesito tener en el archivo de configuración (declarado en Zend_Application). El problema lo tengo a la hora de accedes ésta desde el Plugin.

La única posibilidad que he visto es declarar el config con Zend_Registre desde el Bootstrap; pero para ello estoy obligado a hacerlo cada vez en cada proyecto y me parece un poco “raro”:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initConfig()
    {
        $config = new Zend_Config($this->getOptions(), true);
        Zend_Registry::set('config', $config);
        return $config;
   }
   ....

Otra manera, más fea, es re-declarar el config file desde el plugin; pero estaría en la misma porque tendría que poner la ruta del file.

Alguna idea?

Update:

Por fin he encontrado la solución. He podido obtener config del bootstrap a través del controlador; es un poco engorroso pero al final el código es muy cortito:

class myPlugin extends Zend_Controller_Plugin_Abstract
{
    public function routeShutdown($request)
    {
        //optenemos la instancia del Zend_Application_Bootstrap
        $bootstrap = Zend_Controller_Front::getInstance()
                                ->getParam('bootstrap');
        //Ahora si que tenemos acceso al archivo de configuración (application.ini)
        $config = $bootstrap->getOptions();
        var_dump($config)
    }
    ....
}

resources.frontController.plugins.namePlugin = "ClassPlugin"
namePlugin.options.optionA = 1

resources.frontController.plugins.otherNamePlugin = "ClassPlugin"
otherNamePlugin.options.optionA = 1

Aquí pongo unos enlaces para comenzar a leer y poder empezar

• zend application ejemplo zend framework (español)
• bootstrapping con zend application (Español, muy bien explicado)
• Set up a Zend Framework application using Zend_Application (including PHPUnit setup) (Ingles, para mí el mejor. Tienes un Zip para descargar con la estructura y config ya echo)

$feed = Zend_Feed_Reader::import('http://www.planet-php.net/rdf/');
$data = array(
    'title'        => $feed->getTitle(),
    'link'         => $feed->getLink(),
    'dateModified' => $feed->getDateModified(),
    'description'  => $feed->getDescription(),
    'language'     => $feed->getLanguage(),
    'entries'      => array(),
);

foreach ($feed as $entry) {
    $edata = array(
        'title'        => $entry->getTitle(),
        'description'  => $entry->getDescription(),
        'dateModified' => $entry->getDateModified(),
        'author'       => $entry->getAuthor(),
        'link'         => $entry->getLink(),
        'content'      => $entry->getContent()
    );
    $data['entries'][] = $edata;
}

Enlace: Zend_Feed_Reader promoted to Zend Framework trunk (watch out for ZF 1.9!)

[queda por traducir]

ejemplo de uso:

$cacheEnabled = (bool)getenv('THE_CACHE_ENABLED') ? getenv('THE_CACHE_ENABLED') : false;
TheCache::init($cacheEnabled, TMP_DIR.'/the-cache/');

$keyName = 'data-z-a-b'; // unique name describing this data set
$data = TheCache::load($keyName)
if($data === false) {
 $sql = 'SELECT x,y FROM z WHERE a=b';
 $rs = $db->Execute($sql);
 $data = $rs->GetArray();
 TheCache::save($keyName, $data);
}

enlace : http://akrabat.com/php/notes-on-zend_cache/

“..antes de ponermos a inplantar metodologías de trabajo, tenemos que tener la costumbre de crear Test Unitarios para todo lo que programemos.” (no son palabras textuales :] )

Lamentablemente en PHP, la cosa de los TestUnitarios está casi en pañales y es una teréa bastante engorrosa la de crear un test unitario para cada componente que creemos.

PHPUnit, nos intenta facilitar este trabajo con una fántastica herramienta para poder testear nuestras clases.

weierophinney.net está creando una herramienta(aún está en la incubadora) para poder probar las funcionalidades de nuestras aplicaciones con Zend Framework que utilizan MVC.

¿Qué podremos probar con esta herramienta?

• Si la acción no dio lugar a un redireccionamiento, en caso de éxito, redireccionarlo
• Presencia de determinadas cabeceras de respuesta HTTP y / o su contenido
• ¿Qué módulo, controlador, y / o acción se utilizó en la última interacción del bucle de envío?
• ¿Cuál fue la ruta seleccionada?

Enlace a: Testing Zend Framework MVC Applications

un tutorial bastante introductorio para crear una aplicación con ZendFramework.

enlace: http://es.wikibooks.org/wiki/Zend_Framework/Configuracion_Basica

From Swift Mailer to Zend_Mail

tiene varios ejemplos y casos de uso; muy útil para quien todavía no a utilizado esta clase

Por fin he podido sacar una primera versión(pre-alfa) con soporte para sonido, video e imágenes; me fue difícil empezar, más que nada porque me cuesta empezar con algo abstracto. Decidí empezar con algo practico y escogí un grupo de música y les hice la página con todos lo contenidos que encontraba en los servidores públicos.

Elegí el grupo de música La calle 13 (podría haber cogido cualquier otro) y ya tengo la primera versión; aunque voy a cambiar radicalmente la estructura de desarrollo; más que nada porque creo que es absolutamente necesario mejorar los tiempos de respuesta; es más lentos de lo que esperaba. En la siguiente versión, que trabajaré este fin de semana.

Aquí os presento:

En la próxima versión lo pondré todo en ajax, instalaré un sistema de cache para agilizar las peticiones; cambiaré el diseño web.

Hasta la próxima; que os contaré los problemillas que he tenido al crear la aplicación; un bug en Zend_Service_Flickr (que solucioné), bug en el sistema de cache con Zend_Cache_File