Controladores¶

form¶

$this->params['form']

Cualquier dato POST de cualquier formulario se almacena aquí, incluyendo información también hallada en $_FILES.

admin¶

$this->params['admin']

Contiene el valor 1 si la acción (action) actual fue invocada mediante enrutamiento «admin».

bare¶

$this->params['bare']

Almacena un 1 si el diseño (layout) actual está vacío; 0 si no.

isAjax¶

$this->params['ajax']

Almacena un 1 si la petición actual es una llamada ajax; 0 si no. Esta variables sólo se establece si el componente RequestHandler es usado en el controlador.

controller¶

$this->params['controller']

Almacena el nombre del controlador actual que está sirviendo la petición. Por ejemplo, si fue pedida la URL /posts/view/1, $this->params['controller'] será igual a «posts».

action¶

$this->params['action']

Almacena el nombre de la acción actual sirviendo la petición. Por ejemplo, si fue pedida la URL /posts/view/1, entonces $this->params['action'] será igual a «view».

pass¶

$this->params['pass']

Almacena la cadena de consulta GET enviada con la petición actual. Por ejemplo, si fue pedida la URL /posts/view/?var1=3&var2=4, entonces $this->params['pass'] será igual a «?var1=3&var2=4».

url¶

$this->params['url']

Almacena la URL actual pedida, junto con los pares clave-valor de variables get. Por ejemplo, si se llamó a la URL /posts/view/?var1=3&var2=4, entonces $this->params['url'] debería contener:

[url] => Array
(
    [url] => posts/view
    [var1] => 3
    [var2] => 4
)

data¶

$this->data

Usado para manejar datos POST enviados desde los formularios de FormHelper al controlador.

// El helper FormHelper es usado para crear un elemento de formulario:
$form->text('User.first_name');

El cual al ser renderizado, se ve parecido a:

<input name="data[User][first_name]" value="" type="text" />

Cuando el formulario es enviado al controlador mediante POST, los datos aparecen en this->data

// El valor first_name enviado se puede encontrar aquí:
$this->data['User']['first_name'];

prefix¶

$this->params['prefix']

Establecido al prefijo de enrutado. Por ejemplo, este atributo contendría la cadena «admin» durante una petición a /admin/posts/someaction.

named¶

$this->params['named']

Almacena cualquier parámetro con nombre /clave:valor/ de la cadena de petición de la URL. Por ejemplo, si se pidió la URL /posts/view/var1:3/var2:4, entonces $this->params['named'] debería contener el array:

[named] => Array
(
    [var1] => 3
    [var2] => 4
)

set¶

set(string $variable, mixed $valor)

El método set() es la principal manera de enviar datos desde tu controlador a tu vista (view). Una vez que has utilizado set(), la variable puede ser accedida en tu vista.

<?php

// Primero pasas datos desde el controlador:

$this->set('color', 'azul');

// Despueś, en las vista, puedes utilizar el dato:
?>

Has seleccionado <?php echo $color; ?>ar la tarta.

El método set() también toma una array asociativo como primer parámetro. A menudo, esto puede ser una manera rápida de asignar un conjunto de información a la vista.

Las claves (keys) serán flexionadas (inflected) antes de ser asignadas a la vista (“clave_con_subrayado” se convierte en “claveConSubrayado”, etc.):

<?php

$data = array(
    'color' => 'pink',
    'type' => 'sugar',
    'base_price' => 23.95
);

// hace que $color, $type, y $basePrice
// estén disponibles a la vista:

$this->set($data);

?>

render¶

render(string $action, string $layout, string $file)

El método render() es llamado automáticamente al final de cada acción de controlador pedida. Este método lleva a cabo toda la lógica de la vista (usando los datos que has proporcionado con el método set()), coloca la vista (view) dentro de su diseño (layout) y lo sirve de vuelta al usuario final.

El fichero de vista por defecto utilizado por render es determinado por convenio. Por ejemplo, si se pide la acción search() del controlador RecipesController, será renderizado el fichero de vista en /app/views/recipes/search.ctp.

class RecipesController extends AppController {
    function search() {
        // Render the view in /views/recipes/search.ctp
        $this->render();
    }
...
}

A pesar de que CakePHP lo llamará automáticamente (a menos que hayas establecido $this->autoRender a falso) después de cada lógica de las acciones, puedes utilizar render para especificar un fichero de vista alternativo indicando un nombre de acción en el controlador usando $action.

Si $action comienza por “/” se asume que es un fichero de vista o elemento relativo a la carpeta /app/views. Esto permite el renderizado inmediato de elementos, algo muy útil en las llamadas ajax.

// Render the element in /views/elements/ajaxreturn.ctp
$this->render('/elements/ajaxreturn');

También puedes especificar un fichero de vista alternativo usando el tercer parámetro, $file. Cuando estés usando $file, no olvides utilizar unas pocas de las constantes globales de CakePHP (como VIEWS).

El parámetro $layout te permite especificar el diseño en el que la vista es renderizada.

redirect¶

redirect(string $url, integer $status, boolean $exit)

El método de control de flujo que más frecuentemente utilizarás es redirect(). Este método toma su primer parámetro en forma de URL relativa con formato de CakePHP. Por ejemplo, cuando un usuario ha hecho un pedido satisfactoriamente, probablemente desearás redirigirle a una ventana de recibo.

function realizarPedido() {

    // La lógina para finalizar el pedido va aquí

    if($satisfactorio) {
        $this->redirect(array('controller' => 'pedidos', 'action' => 'gracias'));
    } else {
        $this->redirect(array('controller' => 'pedidos', 'action' => 'confirmar'));
    }
}

También puedes utilizar una URL absoluta o relativa como argumento $url:

$this->redirect('/pedidos/agradecimientos'));
$this->redirect('http://www.ejemplo.com');

También puedes pasar datos a la acción:

$this->redirect(array('action' => 'editar', $id));

El segundo parámetro de redirect() te permite definir un código de estado HTTP que acompañe la redirección. Puede que desees usar 301 (movido permanentemente) o 303 (mirar otro), dependiendo de la naturaleza de la redirección.

El metodo ejecutará exit() tras la redirección a menos que establezcas el tercer parámetro a false.

Si necesitas redirigir a la página origen(referer page) puedes usar:

$this->redirect($this->referer());

flash¶

flash(string $message, string $url, integer $pause)

De manera similar a redirect(), el método flash() es usado para redirigir un usuario a una nueva página tras una operación. El método flash() es diferente en cuanto que muestra un mensaje antes de enviar al usuario a otra URL.

El primer parámetro debería contener el mensaje a mostrar, y el segundo parámetro es una URL relativa con formato CakePHP. CakePHP mostrará el mensaje en $message durante el número de segundos en $pause antes de reenviar al usuario a otra página.

Para mensajes flash en la página, cerciónate de echarle un ojo al método setFlash() del componente SessionComponent.

constructClasses¶

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.

referer¶

Devuelve la URL remitente de la petición actual. Ver `referer <https://en.wikipedia.org/wiki/Referer>`_ en la wikipedia para más información.

disableCache¶

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¶

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);
}

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

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.

paginate¶

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¶

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)
                                   );
    }
}

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

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

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

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

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

Este, como array en requestAction debería ser:

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

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¶

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

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