Configuração¶

Métodos de configuração¶

Configure::write('Company.name','Pizza, Inc.');
Configure::write('Company.slogan','Pizza for your body and soul');

Configure::write(
    'Company',array('name'=>'Pizza, Inc.','slogan'=>'Pizza for your body and soul')
);

Configure::read('Company.name');    //retorno: 'Pizza, Inc.'
Configure::read('Company.slogan');  //retorno: 'Pizza for your body and soul'

Configure::read('Company');

//retorno:
array('name' => 'Pizza, Inc.', 'slogan' => 'Pizza for your body and soul');

Configure::delete('Company.name');

// /app/config/messages.php:
<?php
$config['Company']['name'] = 'Pizza, Inc.';
$config['Company']['slogan'] = 'Pizza for your body and soul';
$config['Company']['phone'] = '555-55-55';
?>

<?php
Configure::load('messages');
Configure::read('Company.name');
?>

Variáveis de Configuração do Núcleo (Core) do CakePHP¶

A classe Configure é usada para gerenciar um conjunto de variáveis de configuração do núcleo(core) do CakePHP. Estas variáveis podem ser encontradas em app/config/core.php. Abaixo está uma descrição de cada variável e como ela afeta sua aplicação CakePHP.

Variável Configure

Descrição

debug

Muda a saída do depuração (debug) do CakePHP.

0 = Modo Produção. Sem saídas. 1 = Mostrar erros e avisos. 2 = Mostrar error, avisos, e SQL. 3 = Mostrar error, avisos, SQL, e dump completo do controlador.

App.baseUrl

Retire o comentário desta definição se você não planeja usar o mod_rewrite do Apache com CakePHP. Não esqueça de remover seus arquivos .htaccess também.

Routing.admin

Retire o comentário desta definição se você gostaria de tirar vantagem das rotas administrativas (admin routes) do CakePHP. Atribua esta variável com o nome da rota administrativa (admin route) que você gostaria de usar. Mais sobre isto depois.

Cache.disable

Quando atribuido para verdadeiro (true), o modo «caching» é desabilitado em todo site (site-wide).

Cache.check

Se atribuido para verdadeiro (true), habilita «caching» na visão (view caching). A habilitação é ainda necessária nos controladores, mas esta variável habilita a detecção destas configurações.

Session.save

Diz ao CakePHP qual mecanismo de armazenamento de sessão usar.

Cache::config(). Muito útil em conjunto com Memcache (em instalações com multiplos servidores de aplicação) para armazenar ambos dados em cache(cached data) e sessões.

Tenha certeza de criar a tabela usando o arquivo SQL localizado em /app/config/sql/sessions.sql.

Session.table

O nome da tabela (não incluindo nenhum prefixo) que armazenará a informação de sessão.

Session.database

O nome do banco de dados que armazenará a informação de sessão.

Session.cookie

O nome do cookie usado para rastrear sessões.

Session.timeout

Tempo de expiração de sessão em segundos. O valor real depende do nível de Segurança (Security.level).

Session.start

Inicia sessão automaticamente quando atribuido para verdadeiro (true).

Session.checkAgent

Quando atribuido para falso (false),sessões do CakePHP não irão verificar para garantir que o agente usuário não mudou entre as requisições.

Security.level

O nível de segurança do CakePHP. O Tempo de expiração de sessão definido em “Session.timeout” é multiplicado de acordo com as configurações aqui presentes.

“high” = x 10 “medium” = x 100 “low” = x 300

session.referer_check

nível de segurança (“Security.level”) é atribuido para alto (“high”).

Security.salt

Uma cadeia de caracteres aleatória usada no hashing de segurança (security hashing).

Asset.timestamp

Acrescenta um timestamp no final dos arquivos da url (CSS, JavaScript, Imagem) que é o horário da última modificação do arquivo em específico.

Valores válidos:

(bool) false - Não faça nada (padrão) (bool) true - Coloca o timestamp apenas quando debug > 0 (string) “force” - Coloca o timestamp sempre (debug >= 0)

Acl.classname, Acl.database

Constantes usadas para a funcionalidade lista de Controle de Acesso (Access Control List) do CakePHP. Veja o capítulo Listas de Controle de Acesso (Access Control Lists) para mais informações.

Configuração de Cache é também encontrada em core.php — Nós estaremos abordando isto depois, logo fique atento.

A Classe Configure pode ser usada para ler e escrever itens de configurações do núcleo (core) em execução (on the fly). Isto pode ser especialmente útil se você quiser ativar o modo de depuração (debug) para uma seção limitada da lógica de sua aplicação, por exemplo.

Configuration Constants¶

Enquanto muitas opções de configurações são manipuladas por Configure, existem algumas constantes que CakePHP usa durante o tempo de execução.

Usando App::import()¶

App::import($type, $name, $parent, $search, $file, $return);

À primeira vista App::import parece complexo, entretanto, na maioria dos casos, apenas 2 argumentos são necessários.

Importando Core Libs¶

Bibliotecas do Core como Sanitize e Xml podem ser carregadas assim:

App::import('Core', 'Sanitize');

O código acima tornaria a classe Sanitize disponível para uso.

Importando Controladores, Modelos, Componentes, Comportamentos (Behaviors), e Ajudantes (Helpers)¶

Todas as classes relacionadas a aplicação devem também ser carregadas com o App::import(). Os seguintes exemplos ilustram como fazer isto.

<?php
// O mesmo que require('controllers/users_controller.php');
App::import('Controller', 'Users');

// Precisamos carregar a classe
$Users = new UsersController;

// Se nós precisarmos que associação de models, componentes e etc, sejam carregadas
$Users->constructClasses();
?>

Carregando Classes de Plugins¶

Carregar classes de plugins funciona da mesma forma de carregar classes de app e do core, exceto que você precisa especificar o plugin do qual você está carregando.

App::import('Model', 'PluginName.Comment');

Carregando Arquivos de Vendor¶

A função vendor() foi descontinuada. Arquivos vendors agora também devem ser carregadas usando App::import(). A sintaxe e argumentos adicionais são ligeiramente diferentes, já que estruturas de arquivos vendors podem mudar bastante, e nem todos os arquivos vendors contém classes.

Os exemplos abaixo ilustram como carregar arquivos vendor a partir de uma série de estruturas de caminhos. Esses arquivos vendors podem estar localizados em qualquer dos diretórios do vendor.

App::import('Vendor', 'geshi');

App::import('Vendor', 'flickr/flickr');

App::import('Vendor', 'SomeName', array('file' => 'some.name.php'));

App::import('Vendor', 'WellNamed', array('file' => 'services'.DS.'well.named.php'));

Rota Padrão¶

Antes de você aprender sobre como configurar suas próprias rotas, você deveria saber que o CakePHP vem configurado com um conjunto de rotas padrão. A configuração padrão de rotas do CakePHP deixará as URLs mais bonitas para qualquer aplicação. Você pode acessar diretamente uma ação via URL colocando seu nome na requisição. Você pode também passar paramêtros para suas ações no controller usando a própria URL.

URL para a rota padrão:
http://example.com/controller/action/param1/param2/param3

A URL /noticias/ler mapeia para a ação ler() do controller Noticias (NoticiasController), e /produtos/ver_informacoes mapeia para a ação verInformacoes() do controller Produto (ProdutosController). Se nenhuma ação é especificada na URL, a ação index() será chamada.

A rota padrão também permite passar parâmetros para as ações usando a URL. Uma requisição /noticias/ler/12 seria equivalente a chamar o método ler(12) no controller Noticias (NoticiasController), por exemplo.

Argumentos passados¶

Argumentos passados são argumentos adicionais ou segmentos de caminho que são usados quando fazer um pedido. Eles são freqüentemente usados para passar parâmetros aos métodos de seu controlador.

http://localhost/calendars/view/recent/mark

No exemplo acima, tanto recent e mark são passados argumentos para CalendarsController::view(). argumentos passados são dadas aos seus controladores de duas maneiras. Primeiro como argumentos para o método de ação chamado e, por outro estão disponíveis em $this->params['pass'] como uma matriz indexada numericamente. Ao utilizar rotas personalizadas que você pode forçar determinados parâmetros de ir para os argumentos passados também. Veja passar parâmetros para uma ação para mais informações.

Parâmetros nomeados¶

Uma novidade no CakePHP 1.2 é a possibilidade de usar parâmetros nomeados. Você pode nomear parâmetros e enviar seus valores usando a URL. Uma requisição /noticias/ler/titulo:primeira+noticia/categoria:esportes teria como resultado uma chamada a ação ler() do controller Noticias (NoticiasController). Nesta ação, você encontraria os valores dos parâmetros título e categoria dentro de $this->passedArgs[“titulo”] e $this->passedArgs[“categoria”] respectivamente.

Alguns exemplos para a rota padrão:

URL mapeadas para as ações dos controladores, usando rotas padrão:

URL: /monkeys/jump
Mapeado para: MonkeysController->jump();

URL: /products
Mapeado para: ProductsController->index();

URL: /tasks/view/45
Mapeado para: TasksController->view(45);

URL: /donations/view/recent/2001
Mapeado para: DonationsController->view('recent', '2001');

URL: /contents/view/chapter:models/section:associations
Mapeado para: ContentsController->view();
$this->passedArgs['chapter'] = 'models';
$this->passedArgs['section'] = 'associations';

Definindo Rotas¶

Definindo suas próprias rotas permite você definir como sua aplicação irá responder a uma dada URL. Defina suas próprias rotas no arquivo /app/config/routes.php usando o método Router::connect().

O método connect() recebe três parâmetros: a URL que você deseja casar, o valor padrão para os elementos de rota, e regras de expressões regulares para ajudar a encontrar elementos na URL.

O formato básico para uma definição de rota é:

Router::connect(
    'URL',
    array('paramName' => 'defaultValue'),
    array('paramName' => 'matchingRegex')
)

O primeiro parâmetro é usado para informar o router sobre que tipo de URL você está tentando controlar. A URL é uma string normal delimitada por barras, as que também pode conter um caracter curinga (*) ou elementos de rota (nomes de variáveis iniciados por dois-pontos). Usar um curinga indica para o roteador que tipo de URLs você quer casar, e especificar elementos de rota permite a você obter parâmetros para as ações de seu controller.

Once you’ve specified a URL, you use the last two parameters of connect() to tell CakePHP what to do with a request once it has been matched. The second parameter is an associative array. The keys of the array should be named after the route elements in the URL, or the default elements: :controller, :action, and :plugin. The values in the array are the default values for those keys. Let’s look at some basic examples before we start using the third parameter of connect().

Router::connect(
    '/pages/*',
    array('controller' => 'pages', 'action' => 'display')
);

This route is found in the routes.php file distributed with CakePHP (line 40). This route matches any URL starting with /pages/ and hands it to the display() method of the PagesController();; The request /pages/products would be mapped to PagesController->display('products'), for example.

Router::connect(
    '/government',
    array('controller' => 'products', 'action' => 'display', 5)
);

This second example shows how you can use the second parameter of connect() to define default parameters. If you built a site that features products for different categories of customers, you might consider creating a route. This allows you link to /government rather than /products/display/5.

Another common use for the Router is to define an «alias» for a controller. Let’s say that instead of accessing our regular URL at /users/someAction/5, we’d like to be able to access it by /cooks/someAction/5. The following route easily takes care of that:

Router::connect(r /> '/cooks/:action/*', array('controller' => 'users', 'action' => 'index')
);

This is telling the Router that any url beginning with /cooks/ should be sent to the users controller.

When generating urls, routes are used too. Using array('controller' => 'users', 'action' => 'someAction', 5) as a url will output /cooks/someAction/5 if the above route is the first match found

If you are planning to use custom named arguments with your route, you have to make the router aware of it using the Router::connectNamed function. So if you want the above route to match urls like /cooks/someAction/type:chef we do:

Router::connectNamed(array('type'));
/>Router::connect(
'/cooks/:action/*', array('controller' => 'users', 'action' => 'index')
);

You can specify your own route elements, doing so gives you the power to define places in the URL where parameters for controller actions should lie. When a request is made, the values for these route elements are found in $this->params of the controller. This is different than named parameters are handled, so note the difference: named parameters (/controller/action/name:value) are found in $this->passedArgs, whereas custom route element data is found in $this->params. When you define a custom route element, you also need to specify a regular expression - this tells CakePHP how to know if the URL is correctly formed or not.

Router::connect(
    '/:controller/:id',
    array('action' => 'view'),
    array('id' => '[0-9]+')
);

This simple example illustrates how to create a quick way to view models from any controller by crafting a URL that looks like /controllername/id. The URL provided to connect() specifies two route elements: :controller and :id. The :controller element is a CakePHP default route element, so the router knows how to match and identify controller names in URLs. The :id element is a custom route element, and must be further clarified by specifying a matching regular expression in the third parameter of connect(). This tells CakePHP how to recognize the ID in the URL as opposed to something else, such as an action name.

Once this route has been defined, requesting /apples/5 is the same as requesting /apples/view/5. Both would call the view() method of the ApplesController. Inside the view() method, you would need to access the passed ID at $this->params['id'].

One more example, and you’ll be a routing pro.

Router::connect(
    '/:controller/:year/:month/:day',
    array('action' => 'index', 'day' => null),
    array(
        'year' => '[12][0-9]{3}',
        'month' => '(0[1-9]|1[012])',
        'day' => '(0[1-9]|[12][0-9]|3[01])'
    )
);

This is rather involved, but shows how powerful routes can really become. The URL supplied has four route elements. The first is familiar to us: it’s a default route element that tells CakePHP to expect a controller name.

Next, we specify some default values. Regardless of the controller, we want the index() action to be called. We set the day parameter (the fourth element in the URL) to null to flag it as being optional.

Finally, we specify some regular expressions that will match years, months and days in numerical form.

Once defined, this route will match /articles/2007/02/01, /posts/2004/11/16, and /products/2001/05 (remember that the day parameter is optional?), handing the requests to the index() actions of their respective controllers, with the custom date parameters in $this->params.

Passando parâmetros para «action»¶

Assumindo que sua action foi definida como esta e você quer acessas os argumentos usando $articleID ao invés de $this->params['id'], somente adicione um array extra no terceiro parâmetro de Router::connect().

// some_controller.php
function view($articleID = null, $slug = null) {
    // algum código aqui
}

// routes.php
Router::connect(
    // E.g. /blog/3-CakePHP_Rocks
    '/blog/:id-:slug',
    array('controller' => 'blog', 'action' => 'view'),
    array(
        //A ordem importa pois isto irá mapear ":id" para $articleID na sua action
        'pass' => array('id', 'slug'),
        'id' => '[0-9]+'
    )
);

E agora, graças as funcionalidades de roteamento reverso, você pode passar na url um array como o abaixo e o Cake saberá como formar a URL como definido nas rotas.

// view.ctp
// Isto irá retornar um link para /blog/3-CakePHP_Rocks
<?php echo $html->link('CakePHP Rocks', array(
    'controller' => 'blog',
    'action' => 'view',
    'id' => 3,
    'slug' => Inflector::slug('CakePHP Rocks')
)); ?>

Roteando prefixos¶

Várias aplicações necessitam de uma seção para usuários administradores com privilégios de alteração de dados. Muitas vezes isso é definido na url, como /admin/users/edit/5. No CakePHP é possível utilizar uma rota para administradores mapeando a nossa seção no arquivo de configuração para Routing.admin.

Configure::write('Routing.admin', 'admin');

Você pode definir quais métodos do seu controller usarão a rota de administrador bastando iniciar o nome do método com o prefixo admin_. Usando o nosso exemplo para acessar uma url de administração usuários /admin/users/edit/5 deveremos ter o o método admin_edit em nosso UsersController informando que o primeiro parâmetro é o número 5.

Você pode mapear a url /admin para a sua ação inicial admin_index alterando o arquivo de configuração de rotas.

Router::connect('/admin', array('controller' => 'pages', 'action' => 'index', 'admin' => true));

Você pode configurar o seu arquivo de configuração para utilizar vários prefixos também:

Router::connect('/profiles/:controller/:action/*', array('prefix' => 'profiles', 'profiles' => true));

As ações(métodos) que pertençam à seção de profiles devem ter seus nomes iniciados com o prefixo profiles_. A estrutura da url do nosso exemplo da seção de profiles de usuários é /profiles/users/edit/5 que fará chamada ao método profiles_edit no nosso UsersController. É importante lembrar que usando o HTML Helper do cakePHP para montar nossos links já estaremos montando o nosso link de forma correta. Abaixo há um exemplo de como construir o nosso link utilizando o HTML helper.

echo $html->link('Edite seu perfil', array('profiles' => true, 'controller' => 'users', 'action' => 'edit', 'id' => 5));

Você pode setar vários prefixos no roteador do cakePHP criando uma estrutura flexível de URL’s para a sua aplicação.

Plugin de roteamento¶

Plugin de roteamento usa a chave plugin. Você pode criar links que apontam para um plugin, mas acrescentando o plugin chave para a sua matriz url.

echo $html->link('New todo', array('plugin' => 'todo', 'controller' => 'todo_items', 'action' => 'create'));

Inversamente, se o pedido de ativos é um pedido plugin e quiser criar um link que não tem plugin que você pode fazer o seguinte.

echo $html->link('New todo', array('plugin' => null, 'controller' => 'users', 'action' => 'profile'));

Ao definir plugin => null diga o roteador que você deseja criar um link que não faz parte de um plugin.

Extensões de Arquivos¶

Para fazer com que suas rotas manipulem diferentes extensões de arquivos, você precisa de uma linha a mais em seu arquivo de configuração de rotas:

Router::parseExtensions(array('html', 'rss'));

Isto vai informar ao router para desconsiderar as extensões que arquivos correspondentes e então processar o restante.

Se você quiser criar uma URL como /pagina/titulo-da-pagina.html, você deveria criar sua rota como mostrado abaixo:

Router::connect(
    '/pagina/:title',
    array('controller' => 'pages', 'action' => 'view'),
    array(
        'pass' => array('title')
    )
);

E então para criar links que utilizem esta rota, simplesmente use:

$html->link('Título do link', array('controller' => 'pages', 'action' => 'view', 'title' => Inflector::slug('titulo da pagina', '-'), 'ext' => 'html'))

Classes Custom Route¶

Classes Custom Route permitem você extender e alterar a forma como como rotas individuais tratam pedidos e controlam roteamento reverso. Uma classe de rota deve estender CakeRoute e implementar uma ou ambas as match() e parse(). Parse é usado para tratar os pedidos e match é usado para tratar o roteamento reverso.

Você também pode usar um classe de rota personalizada quando estiver fazendo uma rota usando a opção routeClass, e carregar o arquivo que contém sua rota antes de tentar usá-la.

Router::connect(
     '/:slug',
     array('controller' => 'posts', 'action' => 'view'),
     array('routeClass' => 'SlugRoute')
);

Esta rota criará um instância de SlugRoute e permite você implementar uma manipulação de parâmetros personalisada.