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.

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']);

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.

Para ello utilizaremos el editor FCKeditor. Es un software gratuito, aunque también existe versión comercial, y que permite manipular el texto como si se tratase de MS Word o OpenOffice Writer, conocidos por la mayoría de los usuarios.

Haremos la integración de la siguiente manera:

1. Descargamos de la página web de FCKEditor el editor, lo descomprimimos y copiamos su contenido en /app/webroot/js. No es necesario copiar la carpeta samples, si no queremos. De esta manera hemos copiado en /app/webroot/js varios ficheros y una carpeta llamada editor.

2. Copiamos en /app/views/helpers el FckHelper y lo importamos en el controlador en el que queramos que se vea el editor. Necesitamos también importar el helper Ajax.

- FCKHelper (/app/views/helpers/fck.php):

class FckHelper extends HtmlHelper {

var $Width = 500;
var $Height = 300;

function load($id, $width=null, $height=null, $toolbar = 'Default') {
$did = Inflector::camelize(str_replace('/', '_', $id));
if($width){ $this->Width = $width; }
if($height){ $this->Height = $height; }
$js = $this->webroot.'js/';
return<<<FCK_CODE
<script type="text/javascript">
fckLoader_$did = function () {
var bFCKeditor_$did = new FCKeditor('$did');
bFCKeditor_$did.BasePath = '$js';
bFCKeditor_$did.ToolbarSet = '$toolbar';
bFCKeditor_$did.Width = $this->Width;
bFCKeditor_$did.Height = $this->Height;
bFCKeditor_$did.ReplaceTextarea();
}
fckLoader_$did();
</script>
FCK_CODE;
}
function fileBrowserInput($fieldName, $htmlAttributes = array(), $return = false) {
$output = $this->input($fieldName, $htmlAttributes, $return);
if (!isset($htmlAttributes['id'])) {
$htmlAttributes['id'] = $this->model . Inflector::camelize($this->field);
}
$output .= '<script type="text/javascript">';
$output .= "//<![CDATA[\n";
$output .= "function openFileBrowser(id){\n";
$output .= "var fck = new FCKeditor(id);\n";
$output .= "fck.BasePath = '".$this->webroot."js/'\n";
$output .= "var url = fck.BasePath + 'editor/filemanager/browser/default/browser.html?Type=Image&amp;Connector=connectors/php/connector.php';\n";
$output .= "var sOptions = 'toolbar=no,status=no,resizable=yes,dependent=yes,scrollbars=yes';\n";
$output .= "sOptions += ',width=640';\n";
$output .= "sOptions += ',height=480';\n";
$output .= "window.SetUrl = function(fileUrl){\n";
$output .= "\$(id).value = fileUrl;\n";
$output .= "}\n";
$output .= "var oWindow = window.open( url, 'FCKBrowseWindow', sOptions ) ;\n";
$output .= "}\n";
$output .= "//]]>\n";
$output .= '</script>';
$output .= '<a href="#" onclick="openFileBrowser(\''.$htmlAttributes['id'].'\'); return false;">select an image...</a>';
return $output;
}
}

- En el controlador:

var $helpers = array('Fck', 'Ajax');

3. Y en la vista, lo asociamos con el input que queramos a través de su identificador, enlazando previamente el fichero javascript correspondiente:

echo $javascript->link('fckeditor');
echo '<h1>Integración de FCKeditor con CakePHP 1.2</h1>';
echo $form->create('Cliente',array('action'=>''));
	echo $form->input('contenido',array('type'=>'textarea', 'label'=>'', 'id' => 'Contenido'));
	echo $fck->load('Contenido', 600, 300);
echo $form->end();

Ya tenemos nuestro editor, que podemos ver en este ejemplo.

En este post vamos a explicar cómo hacer esto, utilizando para ello el calendario DHTML Calendar desarrollado por Dynarch. Es un calendario con licencia GNU y que cubre perfectamente todas las funcionalidades que necesitamos.

Todos los ficheros necesarios para introducir el calendario en nuestra página web, junto con la estructura como se organizan en CakePHP 1.2, pueden descargarse calendario. Lo explicaremos paso a paso.

Lo primero que tenemos que hacer es descargarnos el calendario (podemos hacerlo directamente de la página web de Dynarch, o bien mediante el enlace del párrafo anterior) y descomprimirlo en la carpeta app/webroot/js. Necesitamos también otro fichero javascript, common.js, que también meteremos en esa carpeta. En el body, incluiremos estos ficheros escribiendo:

// Calendar includes
echo $javascript->link('jscalendar-1.0/calendar.js');
echo $javascript->link('jscalendar-1.0/lang/calendar-es.js');
echo $javascript->link('common.js');
// CSS Theme
echo $html->css('../js/jscalendar-1.0/skins/aqua/theme');

Necesitamos ahora implementar un helper para que nos sea mucho más fácil la utilización de este calendario. Lo descargamos del enlace anterior y lo metemos en la carpeta app/views/helpers. Si miramos el código de este helper vemos que tenemos dos funciones, picker y flat, que nos permiten hacer que este calendario aparezca al pulsar un botón o que esté siempre visible en nuestra página.

Ya sólo nos falta introducir este calendario en nuestras páginas.

En el controlador, importamos el helper:

var $helpers = array('DatePicker');

Y en la vista mostramos el calendario:

echo $datePicker->flat('fechaCalendarioFlat', array('id'=>'fechaCalendarioFlat'));
echo $datePicker->picker('fechaCalendarioPicker', array('id'=>'fechaCalendarioPicker'));

Podemos ver una demostración del funcionamiento del calendario en este enlace.

A partir del código proporcionado, podríamos añadir muchas funcionalidades. Por ejemplo, podremos editar el código del helper, para añadirle un observador de javascript al calendario tipo flat y que al pulsar en una fecha nos lleve a otra url, o podríamos hacer que ciertas fechas especiales se coloreen de manera distinta al resto.

NOTA: Tras el comentario de Hijal, hemos comprobado que la versión del helper enlazada en este post es para la versión 1.1 de CakePHP, para la versión 1.2 únicamente habría que modificar las funciones flat y picker, de la manera que se muestra a continuación:

function picker($fieldName, $options = array()) {
$this->_setup();
$htmlAttributes = $this->domId($options);
$divOptions['class'] = ‘date’;
$options['type'] = ‘text’;
$options['div']['class'] = ‘date’;
$options['after'] = $this->Html->link($this->Html->image(’../js/jscalendar-1.0/img.gif’), ‘#’, array(’onClick’=>”return showCalendar(’”.$htmlAttributes['id'].”‘, ‘”.$this->format.”‘); return false;”), null, false);
$output = $this->input($fieldName, $options);
return $output;
}

function flat($fieldName, $options = array()){
$this->_setup();
$htmlAttributes = $this->domId($options);
$divOptions['class'] = ‘date’;
$options['type'] = ‘hidden’;
$options['div']['class'] = ‘date’;
$hoder = ‘<div id=”‘.$htmlAttributes['id'].’_cal’.'”></div><script type=”text/javascript”>showFlatCalendar(”‘.$htmlAttributes['id'].’”, “‘.$htmlAttributes['id'].’_cal’.'”, “‘.$this->format.’”, function(cal, date){document.getElementById(\”.$htmlAttributes['id'].”.’\').value = date});</script>’;
$output = $this->input($fieldName, $options).$hoder;
return $output;
}

Estas dos funciones se encuentran ya modificadas en el fichero tar.gz que se adjunta en el post. Junto con otra modificación surgida tras el siguiente comentario en el foro http://cakephp.hospedaxes.com/dudas/topic/calendario-en-cakephp

Podemos ver el ejemplo de funcionamiento aquí.

Un ejemplo muy claro para esta situación sería dos selects, uno con provincias y el otro con localidades, lo que queremos es que al cambiar de provincia varíe la lista de localidades y muestre las que están en la provincia seleccionada.

Lo haremos utilizando el ajaxHelper, para que no sea necesario la recarga de la página y quede más atractivo.

Lo primero que haremos será definir los modelos de provincias ,localidades y un tercer modelo en el que usaremos los selects, por ejemplo podría ser un modelo de cliente, en el que al insertar un nuevo cliente tendríamos que elegir la provincia y localidad a la que pertenece.

Modelos

Modelo de provincia.

/app/models/provincia.php

class Provincia extends AppModel
{
    var $name = 'Provincia';
}

Modelo de localidad.

/app/models/localidade.php

class Localidade extends AppModel
{
    var $name = 'localidade';
}

Modelo de cliente.

/app/models/cliente.php

class Cliente extends AppModel
{
    var $name = 'Cliente';
}

Controladores

Después de esto tendremos que definir los controladores.

Controlador de localidad.

/app/controllers/localidades_controller.php

class LocalidadesController extends AppController
{
	var $name = 'Localidades';
}

Controlador de provincia.

/app/controllers/provincias_controller.php

class ProvinciasController extends AppController
{
	var $name = 'Provincias';
}

Y por últino el controlador de clientes que será el que implementará la funcionalidad.

Controlador de cliente.

/app/controllers/clientes_controller.php

class ClientesController extends AppController
{
	var $name = 'Clientes';
	var $helpers = array('Ajax');
	var $uses = array('Cliente','Provincia','Localidade');

	function insertar()
	{
		$listadoProvincias = $this->Provincia->find('all', array('fields'=>array('id','nombre'),'order'=>'nombre ASC'));
		$this->set('provincias', Set::combine($listadoProvincias, "{n}.Provincia.id","{n}.Provincia.nombre"));
		$primera_provincia = $this->Provincia->find(null,null,'nombre ASC');
		$listadoLocalidades = $this->Localidade->find('all', array('fields'=>array('id','nombre'),'order'=>'nombre ASC','conditions'=>'Localidade.provincia_id='.$primera_provincia['Provincia']['id']));
		$this->set('localidades', Set::combine($listadoLocalidades, "{n}.Localidade.id","{n}.Localidade.nombre"));

		// RESTO DE LA FUNCIONALIDAD DE INSERCIÓN DE CLIENTES
	}

	function update_select()
	{
		if (!empty($this->data['Localidade']['provincia_id']))
		{
			$provincia_id = $this->data['Localidade']['provincia_id'];
			$localidades = $this->Localidade->find('all', array('fields'=>array('id','nombre'),'order'=>'nombre ASC','conditions'=>array('provincia_id'=>$provincia_id)));
		}
		else
		{
			$localidades = $this->Localidade->find('all', array('fields'=>array('id','nombre'),'order'=>'nombre ASC'));
		}
		$this->set('options', Set::combine($localidades, "{n}.Localidade.id","{n}.Localidade.nombre"));
		$this->render('/elements/update_select', 'ajax');
	}
}

Por un lado tenemos la función insertar, que será una función genérica de inserción de clientes. La parte que a nosotros nos interesa es en la que se inicializan las variables que después utilizaremos en los selects, estas deberán ser arrays en los que cada elemento tenda un identificador y su valor, para que el select pueda utilizarlos en la vista.

En la versión 1.1 de cakephp, esto se podía hacer mediante la función generateList del modelo, función que se ha eliminado en la 1.2.
Por ello ahora es necesario hacerlo en dos pasos, por un lado realizar la búsqueda con un findAll y después utilizar la función combine de la clase Set que genera un array con la estructura deseada, que será el que le pasemos a la vista.

$listadoProvincias = $this->Provincia->find('all', array('fields'=>array('id','nombre'),'order'=>'nombre ASC'));
$this->set('provincias', Set::combine($listadoProvincias, "{n}.Provincia.id","{n}.Provincia.nombre"));

La segunda función update_select, es a la que llamará el ajax para actualizar el listado de localidades a partir de un identificador de provincia.

Como se puede ver en el código, la función coge el identificador de provincia del select y envía a la vista los arrays actualizados de provincias y localidades.

Vistas

Localidades y provincias no tendrán vistas asociadas, ya que no hay ninguna operación en el controlador.

En clientes tendremos que crear la vista para la operación insertar del controlador, esta podría ser algo como esto:

/app/views/clientes/insertar.ctp

echo $form->create('Inscripcione',array('action'=>'insertar'));
echo $form->inputs(array('legend'=>'Actualizar Provincias',
		'Localidade.provincia_id' => array('label'=> 'Provincia','showEmpty'=>'false','id'=>'provincias'),
		'Alumno.localidade_id' => array('label'=> 'Localidad','showEmpty'=>'false','id'=>'localidades'),
			));
echo $form->end();

$options = array('url' => 'update_select','update' => 'localidades');
echo $ajax->observeField('provincias',$options);

La vista será muy sencilla, un formulario con dos selects, uno de localidades y otro de provincias y una llamada al ajaxHelper en la que se indica que cada vez que se modifique el valor del select provincias, se llame a la función update_select y actualice el select de localidades.

Este select se actualizará con los valores devueltos por la vista de update_select, que lo único que hace es imprimir todos los nombres de localidades devueltos por la función del controlador.

/app/views/elements/update_select.ctp
if(!empty($options)) {
  foreach($options as $k => $v) {
    echo "<option value='$k'>$v</option>";
  }
 }

En este enlace se puede ver un ejemplo de funcionamiento.

Desde hace unos días está disponible en la página de cakephp, una nueva versión, la 1.2.0.7125 RC1, de este framework de desarrollo escrito en php, del que hablamos en nuestro blog y en el que desarrollamos la gran mayoría de las webs que se crean en nuestra empresa.

Lo importante de esta noticia es que el framework ha abandonado la categoría de beta, pasando a ser una versión candidata, cada vez está más cerca el lanzamiento de la versión final.

En esta versión se eliminan gran cantidad de métodos deprecados y se corrigen multitud de errores.

A partir de ahora siempre que hablemos de funcionalidades del cakephp 1.2 nos referiremos a la versión RC1.