Seguiremos la explicación que proporciona MSeven en su web para ir comentando paso a paso cómo utilizar este plugin:

1. Instalación

* Copiamos los ficheros proporcionados en la carpeta plugins

* Ejecutamos el siguiente comando desde la consola de CakePHP (en /cake/console/):

cake schema run create -path plugins/queue/config/sql -name queue

2. Configuración:

El plugin nos permite añadir un archivo de configuración personalizado (app/config/queue.php), que tendrá el siguiente formato:

// Tiempo de espera cuando no se encuentra una tarea que ejecutar
$config['queue']['sleeptime'] = 1;

// Probabilidad (en %) de que se limpie una tarea antigua
$config['queue']['gcprop'] = 5;

// Timeout por defecto en que el shell espera por la ejecución de un trabajo
$config['queue']['defaultworkertimeout'] = 120;

// Número de reintentos si el trabajo falla o se ha alcanzado el timeout
$config['queue']['defaultworkerretries'] = 4;

// Tiempo (en segundos) después de que el shell ha terminado (0 = ilimitado)
$config['queue']['workermaxruntime'] = 0;

// Tiempo (en segundos) después de que los trabajos completados se eliminen de la base de datos
$config['queue']['cleanuptimeout'] = 3600;

3. Uso

Desde comando podemos utilizar el plugin para llevar a cabo determinadas acciones:

• Help: para mostrar un mensaje de ayuda

  cake queue help

• Add: intenta llamar a la función add() de una tarea, pues podría pasar que las tareas no permitan esta posibilidad.

  cake queue add <taskname>

• Runworker: ejecuta un proceso  que comprueba la cola y ejecuta las tareas pendientes, eliminando las que hayan caducado.

  cake queue runworker

4. Tareas Instaladas

• QueueEmail: tarea para insertar en la cola un email que se enviará utilizando el EmailComponent de CakePHP.

Podríamos crear nuestras propias tareas siguiendo la guía que se encuentra en el archivo cakephp_queue/vendors/shells/tasks/queue_example.php. Nosotros hemos adaptado, por ejemplo, la tarea queue_email.php para utilizar un componente distinto de envío de correo que mejora su funcionamiento y proporciona más opciones de configuración.

5. Uso

5.1 Añadir al modelo Queue.QueuedTask la lista de modelos que se van a utilizar

5.2 Crear los datos que se le van a pasar al email, será un array con la siguiente estructura:

* Settings: todas las opciones de configuración de envío del email.

* Vars: variables que se pasarán a la vista. La propia tarea se encargará de hacer un set, los sets realizados en la función del controlador no los tendrá en cuenta.

array (
   'settings' =>
      array (
        'to' => null,        'subject' => null,
        'charset' => 'UTF-8',
        'from' => null,
        'sendAs' => 'html',
        'template' => null,
        'debug' => false,
        'additionalParams' => '',
        'layout' => 'default'
),
'vars' =>
   array (
   ),
);

Ejemplo:

$email_data = array (
   'settings' =>
      array (
        'attachments' => [fichero_adjunto],
        'from' => [email_origen],
        'layout' => [layout],
        'subject' => [asunto],
        'template' => [template],
        'to' => [destinatario],
),
'vars' =>
   array (
      'asunto' => [asunto],
      'contenido' => [contenido],
      ... // Podríamos incluir tantas variables como consideremos necesario
      'fullBaseUrl' => FULL_BASE_URL, // Utilizaremos esta variable pues si utilizamos la propia de Cake en el template nos devolverá la ruta de la consola, no la de la aplicación
   ),
);

3. Llamamos a la función que añade la tarea a la cola

$this->QueuedTask->createJob('email', $email_data);

Ahora únicamente nos quedaría llamar al Runkworker como se comentó anteriormente y ya tendremos nuestra cola de tareas funcionando.

En nuestros desarrollos siempre definimos las relaciones en los modelos y al hacer consultas find tenemos el problema de que un nivel de recursividad demasiado elevado nos genera demasiada información, ralentizando la ejecución debido a los joins generados, y un nivel inferior no alcanza para obtener las relaciones que deseamos utilizar. Además, en ocasiones, queremos obtener únicamente un modelo de entre todas las relaciones que componen una determinada entidad.

Esto nos llevaba a tener que utilizar llamadas a la función unbind (o bind, si es el caso) del modelo al vuelo, previamente a la utilización de un find, o bien a tener que dividir la consulta en dos llamadas anidadas en un bucle, reduciendo el nivel de recursividad en ambas. La primera de las soluciones quizás complica excesivamente el desarrollo y la segunda reduce el rendimiento de la aplicación.

El Containable Behavior de CakePHP nos resuelve este problema, ya que nos permite filtrar y limitar los modelos que generan las consultas a los modelos, mejorando el rendimiento de la aplicación con un sencillo modo de empleo.

Para utilizar este comportamiento lo primero que tendremos que hacer es definirlo en el modelo, ya sea utilizando la variable $actAs en la clase modelo, o bien, definiéndolo al vuelo en el controlador:

• En el modelo:

  class Noticia extends AppModel {
     var $actsAs = array('Containable');
  }

• En el controlador:

  $this->Noticia->Behaviors->attach('Containable');

Una vez definido el comportamiento, ya podemos utilizarlo.

Si queremos utilizar un find sin recursividad, es decir:

$this->Noticia->recursive = -1;
$this->Noticia->find('all');
// o bien: $this->Noticia->find('all', array('recursive' => -1));

podríamos utilizar lo siguiente:

$this->Noticia->find('all', array('contain' => false));

o bien, utilizando la siguiente sintaxis:

$this->Noticia->contain();
$this->Noticia->find('all');

A continuación veremos un ejemplo con múltiples opciones de utilización:

/**
* Usuario->Perfil
* Usuario->Cuenta->ResumenCuenta
* Usuario->Noticia->AdjuntoNoticia->HistorialAdjuntoNoticia->NotasHistorial
* Usuario->Noticia->Tag
*/
$this->Usuario->find('all', array(
   'contain'=>array(
      'Perfil',
      'Cuenta' => array(
         'ResumenCuenta'
      ),
      'Noticia' => array(
         'AdjuntoNoticia' => array(
            'fields' => array('id', 'nombre'),
            'HistorialAdjuntoNoticia' => array(
            'NotasHistorial' => array(
               'fields' => array('id', 'nota')
            )
         )
      ),
      'Tag' => array(
         'conditions' => array('Tag.nombre LIKE' => '%feliz%')
      )
    )
  )
));

Utilizando esta configuración obtendremos todos los campos de los modelos Usuario, Perfil, Cuenta y ResumenCuenta; y también las Noticias, aunque de los Adjuntos y su Historial únicamente los campos id y nombre. Y, por último, aquellos Tags que incluyan en su nombre la cadena “feliz”. Las demás relaciones del modelo, si las tuviera, no serían resultado de la búsqueda si no se especifican explícitamente.

Es importante tener en cuenta que incluir una condición a este nivel (por ejemplo, al nivel de Tag) sólo afecta al modelo en el que se ha introducido. Por lo tanto, los usuarios seguirán mostrándose igual aunque el array de Tags esté vacío. Se podrían incluir condiciones al find por el procedimiento común para filtrar elementos, aunque deberemos tener en cuenta la recursividad del find, en el caso de que ésta se establezca, pues incluir un modelo en la variable contain no implica que se pueda establecer condiciones a ese nivel si la recursividad no llega hasta él. Además, debemos tener en cuenta que si no establecemos una recursividad adecuada, no podremos llegar a la obtención de los modelos establecidos. Es recomendable no especificar ningún nivel de recursividad al utilizar este behavior.

En el caso de consultas paginadas, se utilizará la variable contain dentro de la función paginate al igual que hemos hecho en el find.

Existen algunas opciones de configuración del comportamiento, que pueden consultarse en el cookbook, documento del que se ha obtenido la información para la publicación  de este post.

Es una paǵina, llamada cakePHP Questions, en la que todos los usuarios que quieran, dejarán sus dudas para que el resto de la comunidad intenten resolverlas.

Es la misma idea que el grupo de google de cakephp, en funcionamiento desde hace mucho tiempo, pero adaptándolo a sus propias necesidades.

La mayor parte de las dudas, por no decir todas, están en inglés, un pequeño problema para los no acostumbrados a la lengua de shakespeare. La falta de documentación en español sigue siendo uno de los grandes problemas de este framework. Por ello, desde este blog intentamos aportar nuestro granito de arena para hacer más fácil el acceso acceso a este mundo, a todos los usuarios de cake.

En la vista donde queremos que se vea el video se añade

<?php
// Librería necesaria para el Flowplayer
   echo $javascript->link('flowplayer/example/flowplayer-3.1.4.min');
?>
<?php
   echo $html->link('', '/files/ejemplo.flv' , array('id' => 'player1' , 'class' => 'video'));
?>
<script language="JavaScript">
   // Función para cargar el Flowplayer en la zona correspondiente
   flowplayer(
    "player1",
    "<?php echo Router::url("/"); ?>js/flowplayer/flowplayer-3.1.5.swf",
    {
      clip: {
               autoPlay: false,
	       autoBuffering: true
	     }
     }
    );
</script>

Hemos de tener en cuenta la versión de FlowPlayer que hemos descargado en estas dos líneas

echo $javascript->link('flowplayer/example/flowplayer-3.1.4.min');

y

"<?php echo Router::url("/"); ?>js/flowplayer/flowplayer-3.1.5.swf"

que en este caso se corresponden con la versión FlowPlayer 3.1.5

Lo de player1 es por si quieres meter varios videos en la misma página, con lo que el segundo pondría player2 y así sucesivamente (o lo que consideres oportuno)

Además hay que añadir al css

.video{
	display:block;
	width:400px;
	height:300px;
}

FlowPlayer muestra videos que estén en formato flv. Una buena herramienta para convertir nuestros videos avi, mpeg, … a este formato flv es ffmpeg.
Un ejemplo de uso :

ffmpeg -i entrada.avi  salida.flv

En este link podéis ver una demostración.

Utilizaremos también la librería de Javascript Ext JS para poder manipular el árbol gráficamente de manera sencilla, utilizando drag and drop.

Lo primero que tendremos que hacer será añadir en la tabla de la base de datos de la entidad. Utilizando los nombres por defecto de Cake, serían los siguientes campos:

• parent_id: hace referencia al padre del elemento.
• lft: almacena el identificador del elemento de la izquierda en el mismo nivel.
• rght: almacena el identificador del elemento de la derecha en el mismo nivel.

Incluiremos también los campos id y nombre, en una entidad denominada, por ejemplo, Categoria.

El modelo lo haríamos de la siguiente manera:

Este comportamiento tiene funciones muy útiles para la manipulación del árbol. Las más utilizadas quizás sean las siguientes:

• children: devuelve los hijos de un nodo concreto, pudiendo seleccionar si deseamos obtener sólo los hijos directos o todos los hijos en el árbol.
• generatetreelist: función muy útil para obtener los elementos a introducir en un select de HTML.
• getpath: devuelve todo el path hasta el nodo especificado en un array.
• movedown y moveup: sirven para bajar o subir un nivel de un nodo del árbol.
• removefromtree: elimina un nodo del árbol sin perder la estructura, es decir, modificando el padre de sus hijos.
• reorder: reordena un nodo (arrastrando también a sus hijos) en función de los parámetros especificados.

Para realizar la manipulación visual del árbol de categorías crearemos las siguientes funciones en el controlador app/controllers/categorias_controller.php sería:

<?php

class CategoriasController extends AppController{

var $helpers = array( 'Javascript');

// Función para organizar las categorías
function organizar() {}

function getnodes() {
   Configure::write('debug', 0);
   // obtener el identificador del padre que se envío por POST vía Ajax
   $parent = intval($this->params['form']['node']);
   // encontrar los hijos directos del nodo anterior
   $nodes = $this->Categoria->children($parent, true, null, 'Categoria.lft ASC');

   $this->set(compact('nodes'));

   $this->render('getnodes', 'ajax');
}

function reorder()
{
   Configure::write('debug', 0);

   // delta es la diferencia en la posición (1 = nodo siguiente, -1 = nod anterior)
   $node = intval($this->params['form']['node']);
   $delta = intval($this->params['form']['delta']);

   if ($delta > 0) {
      $this->Categoria->movedown($node, abs($delta));
   } elseif ($delta < 0) {
      $this->Categoria->moveup($node, abs($delta));
   }

   exit('1');
}

function reparent()
{
   Configure::write('debug', 0);

   $node = intval($this->params['form']['node']);
   $parent = intval($this->params['form']['parent']);
   $position = intval($this->params['form']['position']);

   // guardamos el nuevo padre de la categoría
   $this->Categoria->id = $node;
   $this->Categoria->saveField('parent_id', $parent);

   // Si position == 0, nos movemos al inicio.
   // En otro caso, calculamos la distancia que nos moveremos ($delta).
   if ($position == 0) {
      $this->Categoria->moveup($node, true);
   } else {
      $count = $this->Categoria->childcount($parent, true);
      $delta = $count - $position - 1;
      if ($delta > 0) {
         $this->Categoria->moveup($node, $delta);
      }
   }

   exit('1');
}
}
?>

Sólo nos quedaría hacer las vistas. En este caso, necesitamos crear 2 vistas: organizar.ctp y getnodes.ctp.

// app/views/categorias/organizar.ctp

<?php echo $html->css('/js/ext-2.0.1/resources/css/ext-custom.css'); ?>
<?php echo $javascript->link('/js/ext-2.0.1/ext-custom.js'); ?>

<script type="text/javascript">
Ext.BLANK_IMAGE_URL = '<?php echo $html->url('/js/ext-2.0.1/resources/images/default/s.gif') ?>';

Ext.onReady(function(){

   var getnodesUrl = '<?php echo $html->url('/categorias/getnodes') ?>';
   var reorderUrl = '<?php echo $html->url('/categorias/reorder') ?>';
   var reparentUrl = '<?php echo $html->url('/categorias/reparent') ?>';

   var Tree = Ext.tree;

   var tree = new Tree.TreePanel({
      el:'tree-div',
      autoScroll:true,
      animate:true,
      enableDD:true,
      containerScroll: true,
      rootVisible: true,
      loader: new Ext.tree.TreeLoader({
         dataUrl:getnodesUrl
      })
    });

   var root = new Tree.AsyncTreeNode({
      text:'Categorías',
      draggable:false,
      id:'root'
   });

   tree.setRootNode(root);
   tree.setHeight('auto');

   var oldPosition = null;
   var oldNextSibling = null;

   tree.on('startdrag', function(tree, node, event){
      oldPosition = node.parentNode.indexOf(node);
      oldNextSibling = node.nextSibling;
   });

   tree.on('movenode', function(tree, node, oldParent, newParent, position){

   if (oldParent == newParent){
      var url = reorderUrl;
      var params = {'node':node.id, 'delta':(position-oldPosition)};
   } else {
      var url = reparentUrl;
      var params = {'node':node.id, 'parent':newParent.id, 'position':position};
   }

tree.disable();

Ext.Ajax.request({
   url:url,
   params:params,
   success:function(response, request) {
      // if the first char of our response is zero, then we fail the operation,
      // otherwise we re-enable the tree
      if (response.responseText.charAt(0) != 1){
         request.failure();
      } else {
         tree.enable();
      }
   },
   failure:function() {
      // we move the node back to where it was beforehand and
      // we suspendEvents() so that we don't get stuck in a possible infinite loop
      tree.suspendEvents();
      oldParent.appendChild(node);
      if (oldNextSibling){
         oldParent.insertBefore(node, oldNextSibling);
      }
      tree.resumeEvents();
      tree.enable();
      alert("Oh no! Your changes could not be saved!");
   }
});
});

tree.render();
root.expand();
});
</script>

<div id="tree-div"></div>

Y la última vista:

<?php
// app/views/categorias/getnodes.ctp
$data = array();
foreach ($nodes as $node)
{   $data[] = array(      "text" => $node['Categoria']['nombre'],      "id" => $node['Categoria']['id']   );
}
echo $javascript->object($data);
?>

Ya sólo nos quedaría descargarnos la librería ExtJS y copiarla en la carpeta /app/webroot/js. En el ejemplo, se ha utilizado la versión 2.0.1.

Categoria

Los cambios más importantes introducidos en la versión 1.3.0 son:

• compatibilidad con PHP 5.3
• nuevo helper de javascript incluyendo soporte para múltiples librerías js
• mejora de la generación de código automática con mejor soporte para plugins y templates.

Ahora mismo estamos metidos de lleno en la utilización de plugins, así que nos alegramos mucho de que le den importancia a esta línea de desarrollo. En cuanto tengamos un poquito de tiempo y las ideas totalmente claras, escribiremos una entrada referente a este tema.

Podemos observar el historial de peticiones anteriores, las variables de la sesión, de la request y de la vista, información de log y estadísticas de memoria utilizada y tiempo de petición.

En primer lugar tendremos que crear un nuevo datasource, estos ficheros van almacenados en el directorio “/app/models/datasources/dbo/”, será un fichero php cuyo nombre comience por dbo_, en nuestro caso lo llamaremos “dbo_mi_dbo.php”.

Tendrá el siguiente contenido:

class DboMiDbo extends DboSource
{
	function connect()
	{
		$this->connected = true;
		return $this->connected;
	}
	function disconnect()
	{
		$this->connected = false;
		return !$this->connected;
	}
}

Después de esto tendremos que cambiar el driver de la base de datos utilizada por nuestro proyecto cakephp, por defecto mysql. Para esto, en el archivo database.php que se encuentra en “/app/config/”, modificamos la variable $default, debería quedar así:

var $default = array(
		'driver' => 'mi_dbo',
		'persistent' => false,
		'host' => '',
		'port' => '',
		'login' => '',
		'password' => '',
		'database' => '',
		'schema' => '',
		'prefix' => '',
		'encoding' => ''
	);

Por último, en todos los modelos que creemos, tendremos que añadir la línea “var $useTable = false;“, para indicarle que ese modelo no va a tener una tabla asociada.

A partir de aquí podremos utilizar toda la potencia de cakephp sin preocuparnos de tener una base de datos instalada.