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.

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.

Hace tiempo que no escribimos ninguna entrada en el blog, casi nos dedicamos únicamente a resolver posibles dudas sobre las entradas ya escritas, esto es debido además de porque es una época en la que tenemos varios proyectos de desarrollo web activos, por la dificultad de encontrar algún tema interesante para vosotros que nos visitáis.

Por eso, desde aquí os invito a que nos plateéis vuestras dudas e ideas para nuevos artículos, ¡qué mejor para escribir un blog para nuestros visitantes que que sean ellos quienes nos indican los temas que más les interesan!