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.

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.

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.

1. Utilizar la función error del FormHelper (realizando la llamada desde la vista) o la función invalidate del modelo (si realizamos la validación manual desde el controlador).
2. Utilizar el propio modelo como fuente de estos mensajes de error.

En el primero de los casos utilizaríamos el siguiente código para la vista y el controlador respectivamente:

$form->error('campo', __('MENSAJE_ERROR', true));
$this->Modelo->invalidate('campo', __('MENSAJE_ERROR', true));

y de esta forma buscaría esa clave del mensaje en el fichero de idioma.

La ventaja de hacerlo desde el modelo y no desde las vistas es que nos permite unificar los mensajes de error en cada campo y evitar la repetición de este código cuando estemos en formularios distintos que incluyan los mismos campos. El inconveniente es que en el modelo no se permite la utilización de la función __() de CakePHP.

Para solucionar este problema será necesario modificar la clase AppModel de la que extienden todos los modelos y que a su vez extiende de Model para redefinir la función invalidate (podemos ver la definición original en el api de CakePHP). Así, el fichero cake/libs/model/app_model.php quedaría como se muestra a continuación:

<?php
class AppModel extends Model {
   function invalidate($field, $value = true) {
      if (!is_array($this->validationErrors)) {
         $this->validationErrors = array();
      }
      $this->validationErrors[$field] = __($value, true);
   }
}
?>

Con este simple cambio, tenemos los mensajes de error del modelo internacionalizados.

Consulta sencilla

Las consultas más simples, que afectan a una única columna son fáciles de realizar, se resuelven con un find y la condición pasada como un parámetro en la llamada a este método.

De esta manera:

$this->Modelo->find('all',array('conditions'=>'Modelo.columna = valor'))

se generará un select con una condición

where Modelo.columna = valor

Consulta con varias condiciones separadas por AND

Surge la duda de ¿qué sucede si deseamos realizar una consulta con varias condiciones?, se podría hacer poniendo como segundo parámetro del array conditions una cadena con todas las condiciones concatenadas con AND entre ellas, pero cakephp ya pensó en eso y hay una manera más sencilla y más limpia de hacerlo, que es pasar un array con todas las condiciones que deseamos que cumpla la consulta, con el formato Modelo.columna => valor :

De esta manera:

$this->Modelo->find('all',array('conditions'=>array('Modelo.columna' => 'valor','Modelo.columna2' => 'valor2')))

Esta llamada generará una consulta con una condición

where Modelo.columna = valor1 AND Modelo.columna2 = valor2

Consulta utilizando <>, <=, >=, > o <

Si en lugar de querer que todas las columnas coincidan con los valores que se les pasan en el array, queremos que alguna columna sea distinta del valor, la condición debería tener este formato

$this->Modelo->find('all',array('conditions'=>array('Modelo.columna <>' => 'valor','Modelo.columna2' => 'valor2')))

Esta llamada generará una consulta con una condición

where Modelo.columna <> valor1 AND Modelo.columna2 = valor2

Este formato también permitiría además de utilizar el distinto de (<>), utlizar mayor que (>) ,mayor o igual que (>=), menor que (<) o menor o igual que (<=).

Consulta utilizando OR

Una nueva duda surge cuando se nos plantea, ¿qué pasa si en lugar de realizar una consulta con condiciones separadas con AND queremos crear una consulta con las condiciones separada por OR?, pues cakephp también permite hacerlo de manera muy sencilla, creando un find con el siguiente formato:

$this->Modelo->find('all',array('conditions'=>array('OR'=>array('Modelo.columna' => 'valor','Modelo.columna2' => 'valor2'))))

Esto creará una consulta con una condición

where Modelo.columna = valor OR Modelo.columna2 => valor2

Esta opción se puede utilizar con cualquiera de los operadores booleanos AND, OR, NOT, XOR.

Cakephp también permite otras opciones más complejas:

Consulta utilizando IN

¿Qué sucede si queremos utilizar una consulta en la que queramos que una columna coincida con una serie de valores?. Para esto, lo más sencillo sería utilizar la sentencia sql in.
Instintivamente la primera idea que podemos tener para crear una consulta de este tipo es generar una cadena con todos los valores que deseamos pasarle a la consulta y esto concatenarlo con Modelo.columna IN.
Cakephp ya había pensado en esto y ha hecho que sea mucho más sencillo que todo esto, para realizar una consulta con un IN como condición habrá que pasarle un array con los valores que queramos que se compruebe la coincidencia, de este modo:

$valores = array(1,2,3,4,5,6);
$this->Modelo->find('all',array('conditions'=>array('Modelo.columna' => $valores,'Modelo.columna2' => 'valor2')))

where Modelo.columna in (1,2,3,4,5,6) AND Modelo.columna2 => valor2

Consulta utilizando NOT IN

Si en lugar de que se compruebe la coincidencia con ciertos valores, se compruebe la no coincidencia (NOT IN), haremos la llamada de esta manera:

$valores = array(1,2,3,4,5,6);
$this->Modelo->find('all',array('conditions'=>array('NOT'=>array('Modelo.columna' => $valores),'Modelo.columna2' => 'valor2')))

where Modelo.columna in (1,2,3,4,5,6) AND Modelo.columna2 => valor2

Consulta utilizando BETWEEN

Podría darse la posibilidad de tener que comprobar si el valor de un campo está contenido entre dos valores dados (BETWEEN), para esto igual que para la expresión in se nos ocurriría crear una cadena concatenando los valores y la sentencia sql, pero cakephp permite una forma mucho más sencilla de crearlo:

$this->Modelo->find('all',array('conditions'=>array(array('Modelo.columna BETWEEN ? AND ?' => array(1,8)))))

Esta llamada al find crearía una consulta sql con la siguiente condición:

where Modelo.columna between 1 AND 8

Con todas estas opciones se podrían crear consultas tan complejas como deseemos sin tener que preocuparnos de generar cadenas con el código sql para concatenar a las condiciones, de una manera muy sencilla e intuitiva.

Validaciones con campos vacíos

Hasta hoy, no habíamos encontrado la forma de validar formatos de campos, permitiendo que se encuentren vacíos, directamente en el modelo. Lo que hacíamos era hacer este tipo de comprobaciones manualmente, rompiendo un poco la flexibilidad que nos ofrece CakePHP para hacer las validaciones directamente en el modelo y sin volver a preocuparnos de ellas.

Ahora ya descubrimos la manera de hacerlo. Es una cosa muy simple que habíamos pasado por alto. Simplemente tenemos que pasar un parámetro a la función de validación, de la manera siguiente:

var $validate = array(
   'email' => array(
   'valid' => array( 'rule' => array('email'),
                             'allowEmpty' => true,
                             'message' => 'Formato email inválido')
                             )
              );

Validación a medida

En el modelo introduciremos el siguiente código:

var $validate = array(
    'campo' => array(
                  'valid' => array( 'rule' => 'reglaPropia',
                              'param1'=>'valor',
                              'message' => 'Mensaje de salida')
                              )
                    );

function reglaPropia($value, $params)
{
   $valid = false;
   if (!condicion){
      // Asignamos el valor a $valid en función de la condición que queramos establecer
   }
   return $valid;
}

A la función creada le hemos pasado dos argumentos, aunque el segundo podríamos no ponerlo si no es necesario. Ambos serán arrays, de manera que si queremos acceder al valor del campo a validar tendremos que leer $value['campo'] y para acceder a los parámetros $params['param1'] , pudiendo introducir tantos parámetros como sea necesario.

En esta función podemos utilizar también las funciones de validación de CakePHP. Por ejemplo:

$valid = Validation::custom($value['campo'], $params['param1']);

Todavía no sabemos si aporta algo nuevo. Como en versiones anteriores corrige bugs y por lo que se puede ver en la noticia del lanzamiento aumenta hasta 10 veces la velocidad de la anterior candidata.

Como siempre, iremos comentando las nuevas características e impresiones que tengamos en el desarrollo páginas web, con esta nueva versión candidata.

Utilizamos para implementar este mecanismo el componente de la Bakery de CakePHP para forzar conexiones seguras, y lo utilizaremos de la misma manera que se explica en este artículo, pero añadiéndole la funcionalidad inversa. Lo explicaremos paso a paso:

- Añadimos el componente ssl.php, en la carpeta app/controllers/components/ con el siguiente contenido:

<?php
class SslComponent extends Object {

   var $components = array('RequestHandler');

   var $Controller = null;

   function initialize(&$Controller) {
      $this->Controller = $Controller;
   }

   function force() {
      if(!$this->RequestHandler->isSSL()) {
        $this->Controller->redirect('https://'.$this->__url());
      }
   }

   function unforce() {
      if($this->RequestHandler->isSSL()) {
         $this->Controller->redirect('http://'.$this->__urll());
      }
   }

   function __url() {
      $port = env('SERVER_PORT') == 80 ? '' : ':'.env('SERVER_PORT');
      return env('SERVER_NAME').$port.env('REQUEST_URI');
   }

   function __urll() {
      $port = env('SERVER_PORT') == 443 ? '' : ':'.env('SERVER_PORT');
      return env('SERVER_NAME').$port.env('REQUEST_URI');
   }

}
?>

- Añadimos en el app_controller (cake/libs/controlller/app_controller.php) la redirección a conexión segura para aquellas acciones que nos interese. Ésta es otra diferencia con el artículo de la Bakery, ya que en ésta se hace esa redirección desde cada acción de cada controlador.

<?php
class AppController extends Controller {

   var $components = array( 'Ssl' );

   public function beforeRender(){
      $action = array( 'action1', 'action2' );
      if( in_array( $this->params['action'] , $action ) ){
         $this->Ssl->force();
      }else{
         $this->Ssl->unforce();
      }
   }

}
?>

Podríamos cambiar en este punto la condición por la que nos interese para nuestro caso, por ejemplo, que sean controladores (todas las acciones de ese controlador) los que necesiten añadir este tipo de conexión.