Welcome to The Cookbook

Um controller (controlador) é usado para gerenciar a lógica para uma parte de sua aplicação. Mais comumente, controllers são usados para gerenciar a lógica de um único model(modelo). Por exemplo, se você está construindo um site para uma padaria online, você pode ter um ReceitasController e um IngredientesController gerenciando suas receitas e seus ingredientes. No CakePHP, controllers são nomeados de acordo com o model que manipulam, no plural.

O model Receita é manipulado pelo ReceitasController, o model Produto é manipulado pelo ProdutosController, e por aí vai.

Seus controllers de aplicação são classes que estendem a classe CakePHP AppController, a qual por sua vez estende a classe núcleo Controller. A classe AppController pode ser definida em app/app_controller.php e deve conter métodos que são compartilhados entre todos os seus controllers. A classe AppController estende o Controller que é uma classe padrão da biblioteca CakePHP.

Controllers podem incluir qualquer número de métodos que são geralmente referidos como actions (ações). Actions são métodos do controlador usados para mostrar views. Uma action é um único método de um controlador. O despachante do CakePHP chama actions quando uma requisição casa uma URL com uma action do controller. Retornando ao nosso exemplo da padaria online, nosso ReceitasController pode conter as actions ver(), compartilhar() e buscar(). O controller poderia ser encontrado em app/controllers/receitas_controller.php e poderia conter:

    <?php
    
    # /app/controllers/receitas_controller.php

    class ReceitasController extends AppController {
        function ver($id)     {
            // a lógica da action vai aqui...
        }

        function compartilhar($cliente_id, $receita_id) {
            // a lógica da action vai aqui...
        }

        function buscar($query) {
            // a lógica da action vai aqui...

        }
    }

    ?>

1. <?php
3. # /app/controllers/receitas_controller.php
4. class ReceitasController extends AppController {
5. function ver($id) {
6. // a lógica da action vai aqui...
7. }
8. function compartilhar($cliente_id, $receita_id) {
9. // a lógica da action vai aqui...
10. }
11. function buscar($query) {
12. // a lógica da action vai aqui...
13. }
14. }
15. ?>

Para que você possa usar o controller de forma mais efetiva em sua aplicação, vamos cobrir alguns dos principais atributos e métodos fornecidos pelos controllers do CakePHP.

Usuários PHP4 devem iniciar suas definições de controllers usando o atributo $name. O atributo $name deve conter o nome do controller. Geralmente é apenas a forma plural do nome do model. Isso cuida de alguns dos problemas de nomes de classe do PHP4 e ajuda o CakePHP a encontrar os nomes das coisas.

<?php

#   exemplo de uso do atributo $name do controller

class RecipesController extends AppController {
   var $name = 'Recipes';
}

?>	

1. <?php
2. # exemplo de uso do atributo $name do controller
3. class RecipesController extends AppController {
4. var $name = 'Recipes';
5. }
6. ?>

Os próximos atributos de controller usados com maior frequência dizem ao CakePHP que helpers(Ajudantes), components(Componentes), e models você usará junto com o controller atual. Usar esses atributos disponibiliza essas classes MVC para o controller como variáveis de classe ($this->NomeDoModel, por exemplo).

Por favor perceba que cada controller tem algumas dessas classes disponíveis por padrão, então você pode nem mesmo ter que configurar o seu controller.

Controllers tem por padrão seu model principal disponível. Nosso ReceitasController terá o model Receita disponível em $this->Receita, e nosso ProdutosController também tem acesso ao model Produto em $this->Produto.

Os helpers Html e Session estão sempre disponíveis por padrão, assim como o componente Session. Para aprender mais sobre essas classes, lembre-se de dar uma olhada em suas repectivas sessões mais a frente nesse manual.

<?php

class RecipesController extends AppController {
    var $name = 'Recipes';

    var $uses = array('Recipe', 'User');
    var $helpers = array('Html', 'Ajax');
    var $components = array('Session', 'Email');
}

?>   

1. <?php
2. class RecipesController extends AppController {
3. var $name = 'Recipes';
4. var $uses = array('Recipe', 'User');
5. var $helpers = array('Html', 'Ajax');
6. var $components = array('Session', 'Email');
7. }
8. ?>

Quando estiver definindo esses atributos, tenha certeza de incluir as classes padrão (como Html no array $helpers, por exemplo) se você pretende usá-los.

Alguns poucos atributos existem nos controllers CakePHP que dão maior controle sobre como suas views são embutidas em um layout.

O atributo $layout pode conter o nome do layout salvo em /app/views/layouts. Você especifica um layout atribuindo ao atributo $layout o nome do arquivo de layout menos a extensão .ctp. Se esse atributo não for definido, o CakePHP renderiza o layout default(padrão). Se você não definiu um em /app/views/default.ctp, o layout default do núcle do CakePHP será renderizado.

<?php

#   Usando $layout para definir um layout alternativo

class RecipesController extends AppController {
    function quickSave() {
        $this->layout = 'ajax';
    }
}

?>

1. <?php
2. # Usando $layout para definir um layout alternativo
3. class RecipesController extends AppController {
4. function quickSave() {
5. $this->layout = 'ajax';
6. }
7. }
8. ?>

O atributo $pageTitle do controller torna possível definir o título da página renderizada. Para que isso funcione apropriadamente, seu layout precisa ter embutido a variável $title_for_layout entre as tags <title> no cabeçalho do documento HTML.

Apenas atribua à $pageTitle a string que você quer ver no <title> do seu documento.

Parâmetros do controller estão disponíveis em $this->params no seu controller CakePHP. Essa variável é usada para dar acesso à informação sobre a requisição atual. O uso mais comum do $this>params é obter acesso à informação que foi enviada ao controller via operações POST ou GET.

$this->params['form']

Qualquer dado do POST de qualquer formulário é guardado aqui, incluindo também informação encontrada em $_FILES.

$this->params['bare']

Guarda 1 se o layout atual está vazio, 0 se não.

$this->params['isAjax']

Guarda 1 se o layout atual é 'ajax', 0 se não. Essa variável só é configurada se o component RequestHandler está sendo usado no controller.

$this->params['controller']

Guarda o nome do controller atual manipulando a requisição. Por exemplo, se a URL /posts/ver/1 foi requisitada, $this->params['controller'] será igual à 'posts'.

$this->params['action']

Guarda o nome da action atual manipulando a requisição. Por exemplo, se a URL /posts/ver/1 é requisitada, $this->params['action'] será igual 'ver'.

$this->params['pass']

Guarda a query string GET passada com a requisição atual. Por exemplo, se a URL /posts/ver/?var1=3&var2=4 foi requisitada, $this->params['pass'] será igual à '?var1=3&var2=4'.

$this->params['url']

Guarda a URL atual requisitada, com os pares chave-valor das variáveis GET. Por exemplo, se a URL /posts/view/?var1=3&var2=4 foi chamada, $this->params['url'] conterá:

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

1. [url] => Array
2. (
3. [url] => posts/view
4. [var1] => 3
5. [var2] => 4
6. )

$this->data

Usado para manipular os dados POST enviados dos formulários FormHelper ao controller.

<?php

// O FormHelper é usado para criar um elemento form:

$form->text('Usuario.primeiro_nome');

// Quando rederizado, se parece com: 

<input name="data[Usuario][primeiro_nome]" value="" type="text" />

// Quando o formulário é enviado para o controller via POST,
// os dados são mostrados em $this->data.

//The submitted first name can be found here:
$this->data['Usuario']['primeiro_nome'];

?>

1. <?php
2. // O FormHelper é usado para criar um elemento form:
3. $form->text('Usuario.primeiro_nome');
4. // Quando rederizado, se parece com:
5. <input name="data[Usuario][primeiro_nome]" value="" type="text" />
6. // Quando o formulário é enviado para o controller via POST,
7. // os dados são mostrados em $this->data.
8. //The submitted first name can be found here:
9. $this->data['Usuario']['primeiro_nome'];
10. ?>

$this->params['form']

1. $this->params['form']

Any POST data from any form is stored here, including information also found in $_FILES.

$this->params['bare']

1. $this->params['bare']

Stores 1 if the current layout is empty, 0 if not.

$this->params['ajax']

1. $this->params['ajax']

Stores 1 if the current layout is set to ‘ajax’, 0 if not. This variable is only set if the RequestHandler Component is being used in the controller.

$this->params['controller']

1. $this->params['controller']

Stores the name of the current controller handling the request. For example, if the URL /posts/view/1 was requested, $this->params['controller'] would equal "posts".

$this->params['action']

1. $this->params['action']

Stores the name of the current action handling the request. For example, if the URL /posts/view/1 was requested, $this->params['action'] would equal "view".

$this->params['pass']

1. $this->params['pass']

Stores the GET query string passed with the current request. For example, if the URL /posts/view/?var1=3&var2=4 was requested, $this->params['pass'] would equal "?var1=3&var2=4".

$this->params['url']

1. $this->params['url']

Stores the current URL requested, along with key-value pairs of get variables. For example, if the URL /posts/view/?var1=3&var2=4 was called, $this->params['url'] would contain:

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

1. [url] => Array
2. (
3. [url] => posts/view
4. [var1] => 3
5. [var2] => 4
6. )

$this->data

1. $this->data

Used to handle POST data sent from the FormHelper forms to the controller.

<?php

// The FormHelper is used to create a form element:

$form->text('User.first_name');

// When rendered, it looks something like:

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

// When the form is submitted to the controller via POST,
// the data shows up in $this->data.

//The submitted first name can be found here:
$this->data['User']['first_name'];

?>

1. <?php
2. // The FormHelper is used to create a form element:
3. $form->text('User.first_name');
4. // When rendered, it looks something like:
5. <input name="data[User][first_name]" value="" type="text" />
6. // When the form is submitted to the controller via POST,
7. // the data shows up in $this->data.
8. //The submitted first name can be found here:
9. $this->data['User']['first_name'];
10. ?>

Ainda que você possa dar uma olhada nos detalhes de todos atributos de controllers na API, existem outros atributos de controllers que merecem suas próprias sessões no manual.

O atributo $cacheAction serve para criar cache das views, e o atributo $paginate é usado para criar a paginação padrão para o controller. Para mais informação sobre como usar esses atributos, dê uma olhada em suas respectivas sessões mais a frente nesse manual.

Para uma lista completa de métodos do controller e suas descrições visite a API CakePHP. Dê uma olhada http://api.cakephp.org/1.2/class_controller.html.

O método set() é a principal forma de enviar dados do seu controller para sua view. Um vez que você usou set(), a variável pode ser acessada na sua view.

<?php
    
// Primeiro você passa os dados do controller:

$this->set('cor', 'pink');

// Então, na view, você pode utilizar os dados:

Você selecionou a cor  para colorizar o cake.

?>

1. <?php
3. // Primeiro você passa os dados do controller:
4. $this->set('cor', 'pink');
5. // Então, na view, você pode utilizar os dados:
6. Você selecionou a cor <?php echo $cor; ?> para colorizar o cake.
7. ?>

O método set() também pega um array associativo como seu primeiro parâmetro. Esse pode ser geralmente uma caminho rápido para atribuir um grupo de informações para a view. Perceba que os índices de seu array sofrerão inflection antes de serem atribuídos à view ('indice_com_underline' se torna 'indiceComUnderline', etc.):

<?php
    
$dados = array(
    'cor' => 'pink',
    'tipo' => 'açucar'’,
    'preco_base' => 23.95
);

// fazem $cor, $tipo, e $precoBase
// disponíveis na view:

$this->set($data);  

?>

1. <?php
3. $dados = array(
4. 'cor' => 'pink',
5. 'tipo' => 'açucar'’,
6. 'preco_base' => 23.95
7. );
8. // fazem $cor, $tipo, e $precoBase
9. // disponíveis na view:
10. $this->set($data);
11. ?>

O método render() é automaticamente chamado ao final de cada action do controller requisitada. Esse método executa toda a lógica da view (usando dados que você forneceu usando o método set()), insere a view dentro do layout e o serve de volta para o usuário final.

O arquivo de view padrão renderizado é determinado por convenção. Se a action buscar() do ReceitasController é requisitada, o arquivo de view /app/views/receitas/buscar.ctp será renderizado.

Ainda que o CakePHP vá automaticamente chamá-lo (a menos que você configure $this->autoRender para false) depois de cada lógica de action, você pode usá-lo para especificar um arquivo de view alternativo configurando o nome da action no controller usando $action. Você pode também especificar um arquivo alternativo um terceiro parâmetro, $file. Quando usar $file, lembre-se de utilizar um pouco das constantes globais do CakePHP (como a VIEWS).

O parâmetro $layout permite especificar o layout na qual a view é renderizada.

set(string $var, mixed $value)

1. set(string $var, mixed $value)

The set() method is the main way to get data from your controller to your view. Once you've used set(), the variable can be accessed in your view.

<?php
    
//First you pass data from the controller:

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

//Then, in the view, you can utilize the data:

You have selected  icing for the cake.

?>

1. <?php
3. //First you pass data from the controller:
4. $this->set('color', 'pink');
5. //Then, in the view, you can utilize the data:
6. You have selected <?php echo $color; ?> icing for the cake.
7. ?>

The set() method also takes an associative array as its first parameter. This can often be a quick way to assign a set of information to the view. Note that your array keys will be inflected before they get assigned to the view (‘underscored_key’ becomes ‘underscoredKey’, etc.):

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

//make $color, $type, and $basePrice 
//available to the view:

$this->set($data);  

?>

1. <?php
3. $data = array(
4. 'color' => 'pink',
5. 'type' => 'sugar',
6. 'base_price' => 23.95
7. );
8. //make $color, $type, and $basePrice
9. //available to the view:
10. $this->set($data);
11. ?>

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

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

The render() method is automatically called at the end of each requested controller action. This method performs all the view logic (using the data you’ve given in using the set() method), places the view inside its layout and serves it back to the end user.

The default view file used by render is determined by convention. If the search() action of the RecipesController is requested, the view file in /app/views/recipes/search.ctp will be rendered.

Although CakePHP will automatically call it (unless you’ve set $this->autoRender to false) after every action’s logic, you can use it to specify an alternate view file by specifying an action name in the controller using $action. You can also specify an alternate view file using the third parameter, $file. When using $file, don’t forget to utilize a few of CakePHP’s global constants (such as VIEWS).

The $layout parameter allows you to specify the layout the view is rendered in.

O método de controle de fluxo que você vai usar com maior freqüência é o redirect(). Esse método pega seu primeiro parâmetro na forma de uma URL relativa CakePHP. Quando um usuário fez uma compra com sucesso, você provavelmente irá redirecioná-lo para a tela de recibo.

<?php
	
function comprar() {

    // A lógica para finalizar a compra vai aqui...

    if($sucesso) {
        $this->redirect('/compras/obrigado');
    } else {
        $this->redirect('/compras/confirmar');
    }
}

?>

1. <?php
3. function comprar() {
4. // A lógica para finalizar a compra vai aqui...
5. if($sucesso) {
6. $this->redirect('/compras/obrigado');
7. } else {
8. $this->redirect('/compras/confirmar');
9. }
10. }
11. ?>

O segundo parâmetro do redirect() lhe permite definir um código de status HTTP para acompanhar o redirecionamento. Você pode querer usar 301 (movido permanentemente) ou 303 (veja outro), dependendo da natureza do redirecionamento.

Esse método não chama exit() depois de redirecionar a menos que você configure o terceiro parâmetro para true.

Similarmente, o método flash() é usado para direcionar o usuário para uma nova página depois de uma operação. O método flash() é diferente pelo fato de mostrar uma mensagem antes de passar o usuário para uma outra URL.

O primeiro parâmetro deve guardar a mensagem a ser mostrada, e o segundo parâmetro é uma URL relativa CakePHP. CakePHP vai mostrar a mensagem na variável $message, por um tempo definido em segundos na variável $pause antes de direcionar o usuário.

Para mensagens flash dentro da página, dê uma olhada no método setFlash() do component Session.

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

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

The flow control method you’ll use most often is redirect(). This method takes its first parameter in the form of a CakePHP-relative URL. When a user has successfully placed an order, you might wish to redirect them to a receipt screen.

<?php
	
function placeOrder() {

    //Logic for finalizing order goes here

    if($success) {
        $this->redirect('/orders/thanks');
    } else {
        $this->redirect('/orders/confirm');
    }
}

?>

1. <?php
3. function placeOrder() {
4. //Logic for finalizing order goes here
5. if($success) {
6. $this->redirect('/orders/thanks');
7. } else {
8. $this->redirect('/orders/confirm');
9. }
10. }
11. ?>

The second parameter of redirect() allows you to define an HTTP status code to accompany the redirect. You may want to use 301 (moved permanently) or 303 (see other), depending on the nature of the redirect.

The method will issue an exit() after the redirect unless you set the third parameter to false.

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

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

Similarly, the flash() method is used to direct a user to a new page after an operation. The flash() method is different in that it shows a message before passing the user on to another URL.

The first parameter should hold the message to be displayed, and the second parameter is a CakePHP-relative URL. CakePHP will display the $message for $pause seconds before forwarding the user on.

For in-page flash messages, be sure to check out SessionComponent’s setFlash() method.

Controllers CakePHP vem com callbacks para inserir lógica exatamente antes ou depois das actions serem rederizadas.

Essa função é executada antes de qualquer action no controller. É o lugar ideal para checar uma sessão ativa ou inspecionar permissões.

Chamada após a lógica da action do controller, mas antes da view ser renderizada. Esse callback não é usado geralmente, mas pode ser necessário se você está chamando render() manualmente antes do final de uma dada action.

Chamada depois de toda action do controller.

Chamada depois que uma action tiver sido renderizada.

Esse método carrega os models requeridos pelo controller. Esse processo de carregamento é feito pelo CakePHP normalmente, mas o método é uma boa quando estiver acessando controllers de diferentes perspectivas. Se você precisa do CakePHP em um script de linha de comando ou outro uso de fora, constructClasses() pode ser uma boa.

Retorna a URL referida pela requisição atual.

Usado para dizer ao navegador do usuário não fazer cache dos resultados na requisição atual. Isso é diferente do cache da view, coberto no capítulo anterior.

Use esse método para tornar um grupo de dados enviados por POST (de inputs compatíveis com o helper Html) em um grupo de condições de busca para o model. Essa função oferece um atalho rápido para criar lógica de busca. Por exemplo, um usuário administrativo pode querer ser capaz de buscar compras para saber quais itens precisam ser enviados. Você pode criar um rápido formulário baseado no model Compra. Então a action do controller pode usar os dados enviados do formulário para criar as condições de busca.

function index() {
    $o = $this->Orders->findAll($this->postConditions($this->data));
    $this->set('compras', $o);
}

1. function index() {
2. $o = $this->Orders->findAll($this->postConditions($this->data));
3. $this->set('compras', $o);
4. }

Se $this->data['Compra']['destino'] é igual a "Padaria da Cidade Velha", postConditions converte essa condição para um array compatível para uso no método NomeDoModel->findAll(). Nesse caso, array("Compra.destino" => "Padaria da Cidade Velha").

Se você quer usar um operador SQL diferente entre os termos, forneça-os usando o segundo parâmetro.

/*
Conteúdo de $this->data
array(
    'Compra' => array(
        'num_de_itens' => '4',
        'fornecedor' => 'Trigo Integral LTDA'
    )
)
*/
 
// Vamos pegar compras que tem ao menos 4 itens e contém 'Trigo Integral LTDA'
$c = $this->Compra->findAll($this->postConditions(
    $this->data,
    array('>=', 'LIKE')
));

1. /*
2. Conteúdo de $this->data
3. array(
4. 'Compra' => array(
5. 'num_de_itens' => '4',
6. 'fornecedor' => 'Trigo Integral LTDA'
7. )
8. )
9. */
11. // Vamos pegar compras que tem ao menos 4 itens e contém 'Trigo Integral LTDA'
12. $c = $this->Compra->findAll($this->postConditions(
13. $this->data,
14. array('>=', 'LIKE')
15. ));

O índice nas especificações de operadores é a ordem das colunas no array $this->data. Já que num_de_itens é o primeiro, o operador >= aplica-se a ele.

O terceiro parâmetro lhe permite dizer ao CakePHP que operador booleano SQL usar entre as condições de busca. Strings com 'AND', 'OR', e 'XOR' são todos valores válidos.

Finalmente, se o último parâmetro está configurado para true, e o parâmetro $op é um array, os campos não incluídos em $op não serão incluídos nas condições retornadas.

Esse método de conveniência concatena as várias partes de datas em $this->data antes de salvar. Se você tem inputs de data do helper Form, esse método concatena o ano, mês, dia e hora em uma string mais compatível com banco de dados.

Esse método usa o model padrão do controller (por ex.: o model Cookie para o controller CookiesController) como alvo para a concatenação, mas uma classe alternativa pode ser usada como primeiro parâmetro.

Esse método é usado para paginar os resultados divididos pelos seus models. Você pode especificar tamanhos de páginas, condições de busca do model e mais. Detalhes sobre esse método mais a frente. Dê uma olhada no capítulo de paginação mais a frente nesse manual.

Essa função chama uma action de controller de qualquer lugar e retorna os dados dessa action. A $url passada é uma URL relativa ao CakePHP (/nomedocontroller/nomedaaction/parametros). Se o array $options incluir um valor de returno. AutoRender é automaticamente configurada para true para a action do controller, tendo a requestAction te levando para a view totalmente renderizada.

Nota: apesar de ser possível usar requestAction() para pegar uma view totalmente renderizada, a perda performance que você obtem passando por toda a camada da view novamente na realidade não faz valer a pena. O método requestAction() é melhor usado em conjunto com elements - como um caminho para enviar lógica de negócio para um element antes da renderização.

Primeiro, vamos ver como pegar dados da action do controller. Primeiro, nós precisamos criar a action do controller que retorna algum dado que precisamos em vários lugares através da aplicação:

// Aqui está nosso controller simples:

class UsuariosController extends AppController {
    function pegarListaDeUsuarios() {
        return $this->Usuario->findAll('Usuario.ativo = 1');
    }
}

1. // Aqui está nosso controller simples:
2. class UsuariosController extends AppController {
3. function pegarListaDeUsuarios() {
4. return $this->Usuario->findAll('Usuario.ativo = 1');
5. }
6. }

Imagine que nós precisamos criar uma simples tabela mostrando os usuários ativos no sistema. Ao invés de duplicar o código de geração de lista em outro controller, nós podemos pegar dados do UsuariosController->pegarListaDeUsuarios() ao invés de usar requestAction();

class ProdutosController extends AppController {
    function mostrarProdutosDoUsuario() {
        $this->set(
            'usuarios', 
            $this->requestAction('/usuarios/pegarListaDeUsuarios')
        );

        // Agora a variável $usuarios na view vai ter dados do
        // UsuariosController::pegarListaDeUsuarios().
    }
}   

1. class ProdutosController extends AppController {
2. function mostrarProdutosDoUsuario() {
3. $this->set(
4. 'usuarios',
5. $this->requestAction('/usuarios/pegarListaDeUsuarios')
6. );
7. // Agora a variável $usuarios na view vai ter dados do
8. // UsuariosController::pegarListaDeUsuarios().
9. }
10. }

Se você tem um element na sua aplicação que não é estático, você pode querer usar requestAction() para enviar lógica equivalente à do controller para o element a medida em que você o injeta nas suas views. Apesar de elements sempre tem acesso a qualquer variável da view que o controller passou, essa é uma forma de passar dados para o element vindos de outro controller.

Se você criou uma action do controller que fornece a lógica necessária, você pode pegar dados e passá-lo para o segundo parâmetro do método renderElement() da view usando requestAction().

renderElement(
    'usuarios',
    $this->requestAction('/usuarios/pegarListaDeUsuarios')
);
?>

1. <?php
2. echo $this->renderElement(
3. 'usuarios',
4. $this->requestAction('/usuarios/pegarListaDeUsuarios')
5. );
6. ?>

Se o array '$options' contiver um valor "return", a action do controller será renderizada dentro de um layout vazio e retornada. Dessa forma, a função requestAction() é útil também em situações Ajax onde um pequeno elemento de uma view precisa ser preenchido antes ou durante uma atualização Ajax.

This method loads the models required by the controller. This loading process is done by CakePHP normally, but this method is handy to have when accessing controllers from a different perspective. If you need CakePHP in a command-line script or some other outside use, constructClasses() may come in handy.

Returns the referring URL for the current request.

Used to tell the user’s browser not to cache the results of the current request. This is different than view caching, covered in a later chapter.

postConditions(array $data, mixed $op, string $bool, boolean $exclusive)

1. postConditions(array $data, mixed $op, string $bool, boolean $exclusive)

Use this method to turn a set of POSTed model data (from HtmlHelper-compatible inputs) into set of find conditions for a model. This function offers a quick shortcut on building search logic. For example, an administrative user may want to be able to search orders in order to know which items need to be shipped. You can use CakePHP’s Form- and HtmlHelpers to create a quick form based on the Order model. Then a controller action can use the data posted from that form to craft find conditions:

function index() {
    $o = $this->Orders->findAll($this->postConditions($this->data));
    $this->set('orders', $o);
}

1. function index() {
2. $o = $this->Orders->findAll($this->postConditions($this->data));
3. $this->set('orders', $o);
4. }

If $this->data[‘Order’][‘destination’] equals “Old Towne Bakery”, postConditions converts that condition to an array compatible for use in a Model->findAll() method. In this case, array(“Order.destination” => “Old Towne Bakery”).

If you want use a different SQL operator between terms, supply them using the second parameter.

/*
Contents of $this->data
array(
    'Order' => array(
        'num_items' => '4',
        'referrer' => 'Ye Olde'
    )
)
*/

//Let’s get orders that have at least 4 items and contain ‘Ye Olde’
$o = $this->Order->findAll($this->postConditions(
    $this->data,
    array('>=', 'LIKE')
));

1. /*
2. Contents of $this->data
3. array(
4. 'Order' => array(
5. 'num_items' => '4',
6. 'referrer' => 'Ye Olde'
7. )
8. )
9. */
10. //Let’s get orders that have at least 4 items and contain ‘Ye Olde’
11. $o = $this->Order->findAll($this->postConditions(
12. $this->data,
13. array('>=', 'LIKE')
14. ));

The key in specifying the operators is the order of the columns in the $this->data array. Since num_items is first, the >= operator applies to it.

The third parameter allows you to tell CakePHP what SQL boolean operator to use between the find conditions. String like ‘AND’, ‘OR’ and ‘XOR’ are all valid values.

Finally, if the last parameter is set to true, and the $op parameter is an array, fields not included in $op will not be included in the returned conditions.

This method is used for paginating results fetched by your models. You can specify page sizes, model find conditions and more. Details on this method follow later. Check out the pagination chapter later on in this manual.

requestAction(string $url, array $options)

1. requestAction(string $url, array $options)

This function calls a controller's action from any location and returns data from the action. The $url passed is a CakePHP-relative URL (/controllername/actionname/params). If the $options array includes a 'return' value, AutoRender is automatically set to true for the controller action, having requestAction hand you back a fully rendered view.

Note: while you can use requestAction() to retrieve a fully rendered view, the performance hit you take on running through the whole view layer another time isn't often worth it. The requestAction() method is best used in conjunction with elements–as a way to fetch business logic for an element before rendering.

First, let's look at how to get data from a controller action. First, we need to set up a controller action that returns some data we might need in various places throughout the application:

// Here is our simple controller:

class UsersController extends AppController {
    function getUserList() {
        return $this->User->findAll('User.active = 1');
    }
}

1. // Here is our simple controller:
2. class UsersController extends AppController {
3. function getUserList() {
4. return $this->User->findAll('User.active = 1');
5. }
6. }

Imagine that we needed to create a simple table showing the active users in the system. Instead of duplicating list-generating code in another controller, we can get the data from UsersController->getUserList() instead by using requestAction().

class ProductsController extends AppController {
    function showUserProducts() {
        $this->set(
            'users', 
            $this->requestAction('/users/getUserList')
        );

        // Now the $users variable in the view will have the data from
        // UsersController::getUserList().
    }
}   

1. class ProductsController extends AppController {
2. function showUserProducts() {
3. $this->set(
4. 'users',
5. $this->requestAction('/users/getUserList')
6. );
7. // Now the $users variable in the view will have the data from
8. // UsersController::getUserList().
9. }
10. }

If you have an element in your application that is not static, you might want to use requestAction() to grab controller-like logic for the element as you inject it into your views. While elements always have access to any view variables the controller has passed, this is one way to get element data from another controller.

If you have created a controller action that supplies the logic needed, you can grab that data and pass it to the second parameter of the view's renderElement() method using requestAction().

renderElement(
    'users',
    $this->requestAction('/users/getUserList')
);
?>

1. <?php
2. echo $this->renderElement(
3. 'users',
4. $this->requestAction('/users/getUserList')
5. );
6. ?>

If the $options array contains a 'return' value, the controller action is rendered inside an empty layout and returned. In this way, the requestAction() function is also useful in Ajax situations where a small element of a view needs to be populated before or during an Ajax update.