Hoy quería investigar sobre cómo crear un sistema de URL cortas; lo primero que hay que decir, es que hay cientos de servicios que te generan este tipo de URL, pero siempre es con el dominio de la herramienta, cosa que no es muy recomendable.

De las librerías(resumidas más abajo) que he podido analizar; todas guardan en una base de datos la URL y un identificador que será el que se envía como parámetro. Dentro de estas librerías, se puede separar en tres grupo por la forma de generar ese identificador:

1. Las que crean un indice numérico incremental y lo utilizan como identificador.
2. Las que crear un indice numérico incremental y luego encriptan este número y usan como identificador
3. Las que ecriptan de algún modo la URL de destino y utilizan (el resultado de la encriptación) como identificador.

YourURL

Esta librería ha sido la primera en descartar; porque creo que usa la API de su web para realizar la tarea acortar la URL. Cabe destacar que es una aplicación bastante completa porque tiene una sección para ver el trafico que han tenido las URL generadas.

web: http://yourls.org

Rick URL Shortening Service

Esta librería (en .NET) es del primer grupo; que más o menos nos da una idea de como se monta el sistema.

El principal fallo que le veo; es que se pasa como identificador el ID (numérico) como parámetro y no queda demasiado estético.

En el siguiente screencast (del autor de esta librería) se puede ver bastante bien cómo se monta este sistema(es exactamente igual a como lo monta el segundo grupo):

web: http://www.stum.de/…url-shortening-service…-project/

LilURL

Esta librería es del 2 grupo; aunque hace una encriptación un tanto rara y bastante enrevesada. Hace una encriptación con caracteres alfabéticos en minúscula.

Lo curioso es que no usa el indice incremental; es él mismo quien va creando la secuencia de identificadores. Para que os hagáis una idea de cómo funciona, este es su código para generar el identificador:

$id = $this->get_next_id($this->get_last_id());

Como podéis ver, genera el identificador a partir del último. Esto resultaría interesante si no fuese porque realiza una consulta a la base de datos para poder conocer el último identificador generado y a partir de ahí genera el siguiente.

web: http://lilurl.sourceforge.net/

Loolu

Este pertenece al segundo grupo y sin lugar a duda, para mi, es la mejor manera de encriptar la URL. Aquí directamente se descompone el número en una base (64) y se representa con caracteres numéricos, alfabéticos con minúsculas y mayúsculas. El algoritmo es más que sencillo (está en python):

codeset  = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
base = 62 # len(codeset)
#....
def encode(self, id):
        hash = ""
        while (id > 0):
            hash = self.codeset[int(id % self.base)] + hash
            id = math.floor(id / self.base)
        return hash

Poco más que añadir a lo genial que es esta solución, simple y eficaz.

web: http://code.google.com/p/loolu/

LessN

Esta librería pertenece al tercer grupo; encripta la URL utilizando un CheckSum (de PHP y Mysql) y lo usa como identificador. Código que realiza la encriptación:

$checksum 		= sprintf('%u', crc32($url));
$escaped_url 	= function_exists('mysql_real_escape_string') ? mysql_real_escape_string($url) : mysql_escape_string($url);
//...
mysql_query('INSERT INTO `'.DB_PREFIX.'urls` SET `url`="'.$escaped_url.'", `checksum`='.$checksum);

nota: Cómo podéis ver es muy importante escapar las URL, ya que corremos el peligro de que nos pongan javascript en la url y puede llegar a ejecutarse en el navegador.

web: http://www.shauninman.com/archive/2009/08/17/less_n

Resumen

En este tipo de servicios, es muy importante tener muy en cuenta el rendimiento de nuestra aplicación, ya que una mala arquitectura te puede consumir demasiados recursos. Es por eso que personalmente me quedo con el algoritmo de Loolu que me parece de lo más sencillo y eficiente.

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

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.

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

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

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.

• existe una lista de usuarios(jefes), a los que se les ha enviado un email con un enlaces a mi form
• estos usuarios tienen que confirmar su asistencia.( día y turno fijo)
• estos usuarios pueden invitar a sus empleados; eligiendo día, turno (mañana y tarde) y si van a comer o no. El día es distinto al que van los jefes

if ( $this->input->post('user') == 'new' ){
 $data        = array('boss'=>$dealer->FairafterfaidealerId
 ,'name'         =>$this->input->post('name')
 ,'lastname'     =>$this->input->post('lastname')
 ,'email'        =>$this->input->post('email'));

 $newDealerId = $this->Fairafterthefair->addDealer($data);

 $data        = array('FairafterfaidealerId'=>$newDealerId
 ,'cuisine'  =>$this->input->post('cuisine')
 ,'day'      =>'4'
 ,'hours'    =>'a');

 $this->Fairafterthefair->confirmAssist($data);

 }else{

 $data = array('FairafterfaidealerId'=>$this->input->post('user')
 ,'cuisine'  =>$this->input->post('cuisine')
 ,'day'      =>'4'
 ,'hours'    =>'a');
 $this->Fairafterthefair->confirmAssist($data);

 }

El problema; es que les puse el día y hora a los dos iguales; por lo que la base de datos siempre guarda el mismo día y misma fecha.

$data        = array('FairafterfaidealerId'=>$newDealerId
 ,'cuisine'  =>$this->input->post('cuisine')
 ,'day'      =>'4'
 ,'hours'    =>'a');

El problema no acaba ahí; iluso de mí ejecute esto, para los invitados:

$newDealerId = $this->Fairafterthefair->addDealer($data);

pensando que esa función me devolvería el el ID añadido, pero parece que no. Así que, para que no se me olvido aquí me apunto la url de la documentación de Code Igniter

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)

If you came here to learn about elementary PHP 4 or basic PHP 5, this is for you. Enjoy!”

Enlace: http://devzone.zend.com/node/view/id/627

Enlace: http://blog.osusnet.com/2009/07/16/paradigma-reflection-en-php/