Bienvenido a El Cookbook

Este método carga los modelos requeridos por el controlador. El proceso de carga es realizado por CakePHP normalmente, pero hay que tener a mano este método cuando se accede a los controladores desde una perspectiva diferente. Si necesitas CakePHP en un script de línea de comando o algún otro uso externo, constructClasses() será útil.

Devuelve la URL remitente de la petición actual. Ver referer en la wikipedia para más información.

Usado para indicarle al navegador del usuario que no guarde en caché los resultados de la petición actual. Esto es diferente a guardar en caché una vista (view caching), tratado en un capítulo posterior.

Las cabeceras enviadas para conseguir esto son:

• Expires: Mon, 26 Jul 1997 05:00:00 GMT
• Last-Modified: [current datetime] GMT
• Cache-Control: no-store, no-cache, must-revalidate
• Cache-Control: post-check=0, pre-check=0
• Pragma: no-cache

postConditions(array $datos, mixed $operadores, string $bool, boolean $exclusivo)

Usa este método para convertir un conjunto de datos de modelo recibidor mediante POST (de inputs compatibles con HtmlHelper) en un conjunto de condiciones de búsqueda para un modelo. Esta función ofrece un atajo rápido para la construcción de la lógica de búqueda. Por ejemplo, un usuario administrativo puede querer buscar pedidos para saber qué elementos necesitan ser enviados. Puedes utilizar los ayudantes FormHelper y HtmlHelper para crear un formulario rápido basado en el modelo Pedido. Entonces, una acción de un controlador puede usar los datos recibidos desde ese formulario para encauzar las condiciones de búsqueda:

function index() {
    $condiciones = $this->postConditions($this->data);
    $pedidos = $this->Pedido->find("all",compact('condiciones'));
    $this->set('pedidos', $pedidos);
}

1. function index() {
2. $condiciones = $this->postConditions($this->data);
3. $pedidos = $this->Pedido->find("all",compact('condiciones'));
4. $this->set('pedidos', $pedidos);
5. }

Si $this->data[‘Pedido’][‘destino’] es igual a “Old Towne Bakery”, postConditions convierte esa condición en un array compatible para ser usado en un método Model->find(). En este caso, array(“pedido.destino” => “Old Towne Bakery”).

Si deseas usar un operador SQL distinto entre términos, proporciónalos usando el segundo parámetro.

/*
contenidos de $this->data
array(
    'Pedido' => array(
        'num_items' => '4',
        'referrer' => 'Ye Olde'
    )
)
*/

//Obtengamos los pedidos que tiene como mínimo 4 elementos y contienen ‘Ye Olde’
$condiciones=$this->postConditions(
    $this->data,
    array(
        'num_items' => '>=',
        'referrer' => 'LIKE'
    )
$pedidos = $this->Pedido->find("all",compact('condiciones'));

1. /*
2. contenidos de $this->data
3. array(
4. 'Pedido' => array(
5. 'num_items' => '4',
6. 'referrer' => 'Ye Olde'
7. )
8. )
9. */
10. //Obtengamos los pedidos que tiene como mínimo 4 elementos y contienen ‘Ye Olde’
11. $condiciones=$this->postConditions(
12. $this->data,
13. array(
14. 'num_items' => '>=',
15. 'referrer' => 'LIKE'
16. )
17. $pedidos = $this->Pedido->find("all",compact('condiciones'));

El tercer parámetro te permite decirle a CakePHP qué operador booleano SQL usar entre condiciones de búsqueda. Una cadena de carateres como ‘AND’, ‘OR’ y ‘XOR’ son valores válidos.

Finalmente, si el último parámetro se establece a true y el parámetro $operadores es un array, los campos no incluidos en $operadores no se incluirán en las condiciones devueltas.

Este método es usado para paginar resultados cargados por tus modelos. Puedes especificar tamaño de páginas, condiciones de búsqueda del modelo y más. Mira la sección paginación para más detalles sobre cómo usar paginate.

requestAction(string $url, array $opciones)

Esta función llama a una acción de un controlador de cualquier lugar y devuelve los datos de la acción. La dirección $url pasada es una URL relativa de CakePHP (/nombrecontrolador/nombreaccion/parametros). Para pasar datos extras a la acción del controladores receptor, añádelos al array $options.

Puedes usar requestAction() para obtener una vista completamente renderizada pasando 'return' en las opciones: requestAction($url, array('return'));

Si se utiliza sin caché, requestAction puede llevar a un pobre rendimiento. Es ráramente apropiado usarlo en un controlador o modelo.

Es mejor usar requestAction junto con elementos en caché, como una manera de obtener datos para un elemento antes de renderizar. Usemos el ejemplo de poner un elemento "últimos comentarios" en el diseño (layout). Primero necesitamos crear una función en un controlador que devolverá los datos.

// controllers/comments_controller.php
class CommentsController extends AppController {
    function latest() {
        return $this->Comment->find('all',
                                    array(
                                          'order' => 'Comment.created DESC',
                                          'limit' => 10)
                                   );
    }
}

1. // controllers/comments_controller.php
2. class CommentsController extends AppController {
3. function latest() {
4. return $this->Comment->find('all',
5. array(
6. 'order' => 'Comment.created DESC',
7. 'limit' => 10)
8. );
9. }
10. }

Si ahora creamos un elemento simple para llamar a esa función:

// views/elements/latest_comments.ctp

$comments = $this->requestAction('/comments/latest');
foreach($comments as $comment) {
    echo $comment['Comment']['title'];
}

1. // views/elements/latest_comments.ctp
2. $comments = $this->requestAction('/comments/latest');
3. foreach($comments as $comment) {
4. echo $comment['Comment']['title'];
5. }

Podemos colocar esos elementos en cualquier sitio para obtener la salida usando:

echo $this->element('latest_comments');

1. echo $this->element('latest_comments');

Escrito de esta manera, siempre que el elemento sea renderizado, se realizará una petición al controlador para obtener los datos, los datos serán procesados y devueltos. De todos modos, de acuerdo con el aviso anterior, es mejor utilizar caché de elementos para prevenir procesamiento innecesario. Modificando la llamada a element para que se vea así:

echo $this->element('latest_comments', array('cache'=>'+1 hour'));

1. echo $this->element('latest_comments', array('cache'=>'+1 hour'));

La llamada a requestAction no se realizará mientras que la el archivo de la vista del elemento en cache exista y sea válido.

Además, requestAction ahora toma urls con estilo cake basadas en arrays:

echo $this->requestAction(
                          array(
                                'controller' => 'articles',
                                'action' => 'featured'
                               ),
                          array('return')
                         );

1. echo $this->requestAction(
2. array(
3. 'controller' => 'articles',
4. 'action' => 'featured'
5. ),
6. array('return')
7. );

Esto permite a la llamada a requestAction evitar el uso de Router::url lo que puede incrementar el rendimiento. Las urls basadas en arrays son las mismas que las que HtmlHelper:link usa, con una diferencia. Si estás usando parámetros con nombre en tu url, entonces el array de url debe envolver los parámetros con nombre en la clave 'named'. Esto es porque requestAction sólo combina los argumentos nombrados del array en el array de miembros de Controller::params y no coloca los argumentos con nombre en la clave 'named'.

echo $this->requestAction('/articles/featured/limit:3');

1. echo $this->requestAction('/articles/featured/limit:3');

Este, como array en requestAction debería ser:

echo $this->requestAction(
                          array(
                                'controller' => 'articles',
                                'action' => 'featured',
                                'named' => array(
                                                 'limit' => 3
                                                )
                               )
                         );

1. echo $this->requestAction(
2. array(
3. 'controller' => 'articles',
4. 'action' => 'featured',
5. 'named' => array(
6. 'limit' => 3
7. )
8. )
9. );

A diferencia de otros lugares donde las urls de arrays son análogas a urls de cadenas, requestAction las trata de manera diferente.

Cuando utilices una url de array junto con requestAction() has de especificar todos los parámetros que necesitarás en la acción pedida. Esto incluye parámetros como $this->data y $this->params['form']

loadModel(string $modelClass, mixed $id)

La función loadModel es útil cuando se necesita usar un modelo que no es propiamente el modelo por defecto del controlador o uno de sus modelos asociados.

$this->loadModel('Article');
$recentArticles = $this->Article->find('all', array('limit' => 5, 'order' => 'Article.created DESC'));

1. $this->loadModel('Article');
2. $recentArticles = $this->Article->find('all', array('limit' => 5, 'order' => 'Article.created DESC'));

$this->loadModel('User', 2);
$user = $this->User->read();

1. $this->loadModel('User', 2);
2. $user = $this->User->read();