Configuración¶

Métodos de la Clase Configure¶

write(string $clave, mixed $valor)

Configure::write('Empresa.nombre','Pizza, Inc.');
Configure::write('Empresa.lema','Pizza para tu cuerpo y alma');

Configure::write(
    'Empresa',array('nombre'=>'Pizza, Inc.','lema'=>'Pizza para tu cuerpo y alma')
);

Configure::read('Empresa.nombre');    //devuelve: 'Pizza, Inc.'
Configure::read('Empresa.lema');      //devuelve: 'Pizza para tu cuerpo y alma'

Configure::read('Empresa');

//devuelve:
array('nombre' => 'Pizza, Inc.', 'lema' => 'Pizza para tu cuerpo y alma');

Configure::delete('Empresa.nombre');

load(string $path)

// /app/config/mensajes.php:
<?php
$config['Empresa']['nombre'] = 'Pizza, Inc.';
$config['Empresa']['lema'] = 'Pizza para tu cuerpo y alma';
$config['Empresa']['telefono'] = '555-55-55';
?>

<?php
Configure::load('mensajes');
Configure::read('Empresa.nombre');
?>

Variables de Configuración Principales de CakePHP¶

La clase Configure se usa para manejar un conjunto de variables de configuración de CakePHP. Estas variables pueden ser encontradas en app/config/core.php. Abajo se encuentra una descripción de cada variable y cómo afecta tu aplicación CakePHP

Nota: La configuración de Cache también puede ser encontrada en el archivo core.php — Más adelante cubriremos este tema.

La clase Configure puede ser utilizada para leer y escribir valores durante la ejecución del programa. Esto puede ser especialmente útil si desea deshabilitar el nivel de deburacion («debug») para una sección limita de lógica en tu aplicación, por ejemplo

Constantes de Configuración¶

A pesar de que la mayoría de las opciones de configuración se manejan con la clase Configure, existen unas pocas constantes que utiliza CakePHP durante su ejecución.

Usando App::import()¶

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

A primera vista App::import parece complejo, sin embargo, en la mayoría de los casos es suficiente con tan sólo dos parámetros.

Importando librerías del Core¶

Las librerías del Core, como Sanitize y Xml pueden ser cargadas mediante:

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

Lo anterior hará que la clase Sanitize esté disponible para su uso.

Importando Controladores, Modelos, Ayudantes, Comportamientos y Componentes¶

Todas las clases relacionadas con la aplicación pueden ser importadas con App::import(). Los siguientes ejemplos muestran cómo hacerlo:

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

// Necesitamos cargar la clase
$Users = new UsersController;

// If we want the model associations, components, etc to be loaded
$Users->constructClasses();
?>

Cargando desde Plugins¶

Cargar clases en plugins funciona casi igual que cargar clases ubicadas en el Core o en la aplicación principal, a excepción de que debe especificarse el nombre del plugin donde reside la clase a cargar.

App::import('Modelo', 'NombrePlugin.Comentario');

Cargando Archivos de Terceros¶

La función vendor() ha sido reemplazada. Los archivos de terceros deben ser cargados también mediante App::import(). La sintaxis y los argumentos adicionales son levemente diferentes, debido a que los archivos de terceros y su estructura pueden variar inmensamente, y no todos los archivos de terceros contienen clases.

Los siguientes ejemplos ilustran cómo cargar archivos de terceros en diferentes rutas y estructuras. Los archivos de terceros deben estar ubicados en cualquiera de los directorios vendor.

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

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

App::import('Vendor', 'CiertoNombre', array('file' => 'cierto.nombre.php'));

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

Enrutamiento por Defecto¶

Antes de que aprendas a configurar tus propias rutas, deberías saber que CakePHP viene configurado con un conjunto de rutas por defecto. Estas rutas te llevarán bastante lejos en cualquier aplicación. Puedes acceder a una acción directamente desde el URL colocando su nombre en la petición. También puedes pasar parámetros a las acciones de tus controladores usando el URL.

Patron URL de las rutas por defecto:
http://example.com/controlador/accion/param1/param2/param3

El URL /articulos/ver dirige a la acciónver() action del ArticulosController, y /productos/listaCompleta dirige a la accion to the lista_completa() de ProductosController. Si no se especifica ninguna acción en el URL, se asume que se trata de la acción index().

La configuración inicial de enrutamiento permite pasar parámetros a tus acciones usando el URL. Una petición para /articulos/ver/25 sería equivalente a llamar ver(25) en el ArticulosController, por ejemplo.

Parámetros con Nombre¶

Algo novedoso en CakePHP 1.2 es la habilidad de usar parámetros con nombre (named parameters). Puedes nombrar parámetros y enviar sus valores usando el URL. Una petición para /articulos/ver/titulo:primer+articulo/categoria:general resultaría en una llmada a la accion view() de ArticulosController. En dicha acción, puedes encontrar los valores del título y la categoría dentro de $this->passedArgs[“titulo”] and $this->passedArgs[“categoria”] respectivamente.

Algunos ejemplos que resuman las rutas por defecto puede resultar útil.

URL: /monos/saltar
Dirige a: MonosController->saltar();

URL: /productos
Dirige a: ProductosController->index();

URL: /tareas/ver/45
Dirige a: TareasController->ver(45);

URL: /donaciones/ver/recientes/2001
Dirige a: DonacionesController->ver('recientes', '2001');

URL: /contenidos/ver/capitulo:modelos/seccion:asociaciones
Dirige a: ContenidosController->ver();
$this->passedArgs['capitulo'] = 'modelos';
$this->passedArgs['seccion'] = 'asociaciones';

Enrutamiento por defecto¶

Antes de que leas como configurar tus rutas, deberías saber que CakePHP incluye algunas por defecto. El enrutamiento en CakePHP te ofrece mucho más que cualquier otra aplicación. Puedes acceder directamente a cualquier acción poniéndola solo en la URL. Puedes enviar también variables a la acción a través de la URL.

Patrones de enrutamiento por defecto:
http://example.com/controller/action/param1/param2/param3

La URL /posts/view enruta hacia la accion view() del controlador PostsController y /products/viewClearance enruta hacia la accion view_clearance() del controlador ProductsController. Si la acción no esta definida en la URL, el método index() es asumido por defecto.

El enrutamiento por defecto te permite enviar parámetros a la acción a través de la URL. Una petición hacia /posts/view/25 sería equivalente a llamar a la acción view(25) en el controlador PostsController.

Parámetros con nombre¶

Una nueva característica en CakePHP 1.2 es la posibilidad de setear nombres de parámetros y su valor por la URL. Una petición a /posts/view/title:first+post/category:general resultaría en una llamada a la acción view() del controlador PostsController. En esta acción, podrás encontrar los valores para title y category dentro de $this->passedArgs[“title”] y $this->passedArgs[“category”] respectivamente.

Algunos ejemplos que pueden ser de utilidad.

Acceder a la acción jump() del controlador MonkeysController desde la URL:

URL: /monkeys/jump
Enrutado: MonkeysController->jump();

URL: /products
Enrutado: ProductsController->index();

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

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

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

Defining Routes¶

Defining your own routes allows you to define how your application will respond to a given URL. Define your own routes in the /app/config/routes.php file using the Router::connect() method.

The connect() method takes up to three parameters: the URL you wish to match, the default values for your route elements, and regular expression rules to help the router match elements in the URL.

The basic format for a route definition is:

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

The first parameter is used to tell the router what sort of URL you’re trying to control. The URL is a normal slash delimited string, but can also contain a wildcard (*) or route elements (variable names prefixed with a colon). Using a wildcard tells the router what sorts of URLs you want to match, and specifying route elements allows you to gather parameters for your controller actions.

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(
    '/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. Note that parenthesis (grouping) are not supported in the regular expressions. You can still specify alternates, as above, but not grouped with parenthesis.

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

Pasando parámetros a las acciones¶

Asumiendo que tu action fue definida así y quieres acceder los argumentos usando $articleID en vez de $this->params['id'], tan solo agrega un array extra en el 3er parámetro de Router::connect().

// some_controller.php
function view($articleID = null, $slug = null) {
    // some code here...
}

// routes.php
Router::connect(
    // E.g. /blog/3-CakePHP_Rocks
    '/blog/:id-:slug',
    array('controller' => 'blog', 'action' => 'view'),
    array(
     // el orden es importante ya que esto va a mapear ":id" con $articleID en tu action
        'pass' => array('id', 'slug'),
        'id' => '[0-9]+'
    )
);

Y ahora, gracias a la capacidad de enrutamiento inverso podrás pasar la url como se muestra abajo y Cake sabrá como formar la URL como se definió en los routers.

// view.ctp
// esto devolverá un link a /blog/3-CakePHP_Rocks
<?php echo $html->link('CakePHP Rocks', array(
    'controller' => 'blog',
    'action' => 'view',
    'id' => 3,
    'slug' => Inflector::slug('CakePHP Rocks')
)); ?>

Prefix Routing¶

Muchas aplicaciones necesitan una sección administrativa donde los usuarios con privilegios puedan hacer cambios. Con frecuencia, esto se hace con una URL especial como /admin/users/edit/5. En CakePHP, el admin routing puede activarse dentro del archivo de configuración del core ajustando la ruta de administración para Routing.admin.

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

En tu controlador, será llamada cualquier acción con un prefijo admin_. Recurriendo a nuestro ejemplo de usuarios, acceder a la URL /admin/users/edit/5 debería llamar al método admin_edit de nuestro UsersController pasando 5 como primer parámetro.

Puedes mapear la URL /admin a tu acción admin_index del pages controller usando la ruta

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

Puedes configurar el Router usado múltiples prefijos:

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

Cualquier llamada a la sección Profiles buscaría el prefijo profiles_ en las llamadas a los métodos. Nuestro ejemplo tendría una URL como /profiles/users/edit/5 que llamaría al método profiles_edit en el UsersController. Es también importante recordar que usar el HTML helper para construir tus enlaces, te ayudará a mantener las llamadas a los prefijos. He aquí cómo construir este enlace usando el HTML helper:

echo $html->link('Edit your profile', array('profiles' => true, 'controller' => 'users', 'action' => 'edit', 'id' => 5));

Puedes ajustar múltiples rutas con prefijos usando esta metodología para crear una estructura de URL flexible para tu aplicación.

Rutas y plugins¶

Las rutas a Plugins utilizan la clave plugin. Puedes crear enlaces que apunten a un plugin siempre que añadas la clave plugin al array de la url.

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

Por el contrario, si la petición activa es un plugin y quieres crear un enlace que no tiene plugin, puedes hacerlo como sigue.

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

Al poner plugin => null le estás diciendo al Router que quieres crear un enlace que no forma parte de un plugin.

Extensiones de archivo¶

Para manejar diferentes extensiones de archivo con tus rutas, necesitas una línea extra en el archivo de configuración de rutas:

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

Esto le dirá al router que retire las extensiones de archivo coincidentes y que procese entonces el resto..

Si quieres crear una url como /page/title-of-page.html podrías crear tu ruta como se explica a continuación:

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

Para crear enlaces que se mapeen a esas rutas simplemente usamos:

$html->link('Link title', array('controller' => 'pages', 'action' => 'view', 'title' => Inflector::slug('text to slug', '-'), 'ext' => 'html'))