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

El pasado mes de Junio lanzamos una encuesta sobre el uso de Twitter por parte de los usuarios españoles con el objetivo de conocer en detalle qué atrae y engancha tanto a sus usuarios y cómo usan esta potente red social.

Ahora, fruto de esa encuesta, tengo el placer de anunciarte la publicación del “Estudio del Uso de Twitter en España”, elaborado por adigital, Asociación Española de la Economía Digital.

Entre las principales conclusiones, destacamos que:

• El perfil de usuario registrado en Twitter en España es el de hombre joven, cuya edad oscila entre los 25 y los 44 años, con formación de grado superior y trabajador por cuenta ajena.
• El 94% de los encuestados declara utilizar esta red por motivos profesionales: “Informarse de lo que ocurre en el mundo online”, “mejorar a nivel profesional”, “compartir con los demás reflexiones e ideas” o “ampliar la red de contactos” son los principales objetivos que persiguen los usuarios cuando utilizan Twitter.
• El usuario de Twitter se profesionaliza ya que el 94% de los usuarios afirma publicar tweets de temática profesional; casi el 70% de los usuarios está relacionado/a de una manera u otra con el mundo online a nivel profesional (sólo el 23,3% afirma estar en Twitter por afición); casi un 80% de los usuarios de Twitter tiene estudios superiores.
• El usuario de Twitter quiere encontrar empresas en Twitter: el 94,9% de los usuarios declara seguir a alguna empresa en Twitter; al 73% le gusta encontrar en esta red a aquellas empresas en las que confía y más del 70% estaría dispuesto a recibir varios tweets al día de empresas con las que se siente afín y puedan aportarle algún beneficio.

Puedes acceder al contenido íntegro del Estudio en www.adigital.org/emailing/2010/docs/adigital_Estudio_Uso_Twitter_enEspana_2010.pdf

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

El equipo de Magento presenta una oferta veraniega para los que quieran aprender a gestionar e incluso “desarrollar” sus Tiendas Virtuales con Magento Commerce

Link en spañol: Curso de Magento para el verano
Oficial de Magento: Magento U – Summer Webinar Series

Gracias a Sergio Guerrero por el enlace.

Cierto es que en más de una ocasión es dicho que no tomaría partido a la hora de elegir una web social o herramienta ya que creo que la mayoría de estas están más por la labor comercial que por dar una herramienta potente al usuario, algo que Google hace a la perfección.

Pero también es cierto que para los usuarios comunes y corrientes, les da un poco igual la cantidad de opciones que les pueda dar uno u otro servicio; más bien diría que van donde está la manada y dejan que otros elijan por ellos. Éstos, simplemente, escogen lo que ya escogieron otros sin valor el motivo.

Facebook ha conseguido tener una comunidad de usuarios bastante importante y no me equivoco al decir que ha ganado a Google (Orkut, Wave, …) en el terreno de aplicaciones sociales. Ahora la pregunta del millón es:

¿cómo nos aprovechamos, económicamente, de estos usuarios?

Está claro que  los usuarios no les podemos sacar nada; pero si podemos usar a éstos para que sean más o menos amigos de “otros”. Estos “otros” son, nada más y nada menos, que las empresas, las empresas son las que tienen el dinero y a estos si que podemos sacarle el dinero.

Entonces, creo que es el mejor momento (hace mucho que lo es) para poder dar herramientas a las empresas para poder formar sus propios rebaños grupo de amigos.

Con esto quiero anunciar la integración de este blog con comentarios y oficialmente dedicaré mi tiempo libre a jugar con FB y ver que juguetito puedo hacer.

El próximo post será sobre el uso de este, que tiene unas herramientas bastante útiles:

SERVICIOS WEB DE LA SEDE ELECTRONICA DEL CATASTRO v2.6

Aquí tenéis un vídeo de la instalación y unas cuantas pruebas:

más info: http://phpforandroid.net/

Sobran las palabras tras ver el “código”. En estos momentos es cuando creo que estaría mejor haciendo otra cosa…

Por norma general siempre he utilizado:
PHP

$arr = array('a'=>'nueva variable',
           'b'=>'otra variable más',
           'c'=>'la ultima variable'
           );

$str = $arr['a'].
$arr['b'].
$arr['c']

Javascript

var obj = {
           paramA:'a',
           paramB:'b',
           paramC:'c'
           };

class.
methodA().
methodB().
methodC('.classCss')

En principio esto es lo más normal, o por lo menos lo que he solido ver en casi todo los códigos. Mi gran Dilema viene con el Javascript; que en IE si te dejas una coma al final de un objeto “;}” te tira un lindo error que no sueles saber de dónde viene.

Para evitar este problema; he decidido hacerlo de la siguiente manera:
PHP

$arr = array('a'=>'nueva variable'
           ,'b'=>'otra variable más'
           ,'c'=>'la ultima variable')

$str = $arr['a']
           .$arr['b']
           .$arr['c']

Javascript

var obj = {
           paramA:'a'
           ,paramB:'b'
           ,paramC:'c'
};

class
.methodA()
.methodB()
.methodC('.classCss')

Lo malo de todo este cambio es que ya no soporto ver código con las comas o puntos al final de cada línea.

Que manera de repetir todo el mundo la misma noticia todo el rato.