Konfiguration¶

Configure Methods¶

Configure::write('Company.name','Pizza GmbH');
Configure::write('Company.slogan','Pizza für den Körper und die Seele');

Configure::write(
    'Company',array('name'=>'Pizza GmbH','slogan'=>'Pizza für den Körper und die Seele')
);

Configure::read('Company.name');    //yields: 'Pizza GmbH'
Configure::read('Company.slogan');  //yields: 'Pizza for your body and soul'

Configure::read('Company');

//Rückgabewert:
array('name' => 'Pizza GmbH', '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 für deine Seele und deinen Körper.';
$config['Company']['telefon'] = '555-55-55';
?>

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

CakePHP Kernkonfiguration¶

Die Klasse Configure wird benutzt, um einen Satz von Variablen mit CakePHPs Kernconfiguration zu verwalten. Diese Variablen findet man in app/config/core.php. Es folgt eine Beschreibung der Variablen und inwiefern sie CakePHP-Anwendung beeinflussen.

Die Cache-Konfiguration findet sich auch in core.php - wir sprechen das später nochmal an, also bleib dran.

Die Klasse Configure kann benutzt werden, um die Kernkonfiguration „im Fluge“ (also mitten in deiner Anwendung) zu ändern. Das kann zum Beispiel dann besonders praktisch sein, wenn du die Debug-Einstellungen für einen bestimmten Bereich deiner Anwendung aktivieren möchtest.

Konfigurationskonstanten¶

Obwohl die meisten Konfigurationseinstellungen über Configure gesetzt werden, gibt es ein paar Konstanten, die CakePHP während der Laufzeit benutzt.

Benutzung von App::import()¶

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

Auf den ersten Blick sieht App::import sehr komplex aus, aber in den meisten Fällen sind nur zwei Argumente nötig.

Importieren von Kern-Bibliotheken¶

Kern-Bibliotheken wie Sanitize oder Xml können wie folgt geladen werden:

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

Diese Zeile Code stellt die Sanitize-Klasse bereit.

Importieren von Controllers, Models, Components, Behaviors und Helpers¶

Sämtliche mit der Anwendung verbundenen Klassen sollten mit App::import() geladen werden. Die folgenden Beispiele zeigen wie.

<?php
// Gleichbedeutend mit require('controllers/users_controller.php');
App::import('Controller', 'Users');

// Initialisierung der Klasse
$Users = new UsersController;

// Zum laden der Model-Associations, Komponenten, etc.
$Users->constructClasses();
?>

Laden von Klassen in einem Plugin¶

Das Laden von Klassen in einem Plugin funktioniert ähnlich, wie das Laden von Anwendungs- oder Kern-Klassen, bis auf die Angabe, von welchem Plugin die Klasse geladen werden soll.

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

Laden von Vendor-Dateien¶

Die vendor() Funktion ist veraltet. Vendor-Dateien sollten ebenfalls mit App::import() geladen werden. Syntax und Argumente unterscheiden sich minimal vom Laden anderer Klassen, da Vendor-Klassen sehr unterschiedlich aussehen können und nicht unbedingt Klassen beinhalten müssen.

Die folgenden Beispiele veranschaulichen, wie Vendor-Klassen aus unterschiedlichen Pfaden geladen werden. Die Vendor-Dateien könnten in jedem Vedor-Verzeichnis liegen.

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

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

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

App::import('Vendor', 'TollerName', array('file' => 'services'.DS.'toller.name.php'));

Vordefinierte Routen¶

Bevor du lernst wie man eigene Routen definiert, ist es wichtig zu wissen, dass CakePHP einige vordefinierte Routen hat. Mit den vordefinierten Routen von CakePHP kommt man in den meisten Applikationen schon ziemlich weit. Du kannst auf eine Aktion direkt zugreifen indem du den Namen der Aktion direkt in der URL angibst. Man kann auch die Parameter die für die Aktion möglich sind direkt in der URL angeben.

URL Muster durch die vordefinierten Routen:
http://example.com/controller/action/param1/param2/param3

Die URL /posts/view zeigt direkt auf die view() Aktion (und auch Methode) des PostsController, und /products/view_clearance zeigt auf die viewClearance() Aktion bzw. Methode des ProductsController. Ist keine Aktion in der URL angegeben so wird die index() Aktion implizit benutzt.

Mit den vordefinierten Routen ist es möglich über die URL Parameter an die Aktion zu übergeben. Eine Anfrage wie /posts/view/25 würde die Aktion view() des PostsControllers mit dem Parameter 25 aufrufen: view(25).

Benannte Parameter¶

In CakePHP 1.2 ist die Möglichkeit benannte Parameter zu benutzen neu hinzugekommen. Man kann nun die Parameter benennen und die Werte mit Namen über die URL an den Controller senden. Beispielsweise würde eine Anfrage wie /posts/view/titel:erster+eintrag/Kategorie:allgemein einen Aufruf von der view() Aktion des PostsController zur Folge haben. In dieser Aktion fände man die Parameter „titel“ und „kategorie“ im Array $this->passedArgs[‘titel’] und $this->passedArgs[‘kategorie’].

Einige Beispiele wie die URL mit vordefinierten Routen ausgewertet wird:

URL: /affen/spring
Mapping: AffenController->spring();

URL: /produkte
Mapping: produkteController->index();

URL: /aufgabe/view/45
Mapping: AufgabenController->view(45);

URL: /spenden/view/neueste/2001
Mapping: SpendenController->view('neueste', '2001');

URL: /contents/view/kapitel:modelle/abschnitt:vereinigung
Mapping: ContentsController->view();
$this->passedArgs['kapitel'] = 'models';
$this->passedArgs['abschnitt'] = 'vereinigung';

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.

Passing parameters to action¶

Assuming your action was defined like this and you want to access the arguments using $articleID instead of $this->params['id'], just add an extra array in the 3rd parameter of 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(
        // order matters since this will simply map ":id" to $articleID in your action
        'pass' => array('id', 'slug'),
        'id' => '[0-9]+'
    )
);

And now, thanks to the reverse routing capabilities, you can pass in the url array like below and Cake will know how to form the URL as defined in the routes.

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

Routen mit Präfix¶

Viele Anwendungen benötigen eine Administrationsoberfläche in der privilegierte Benutzer Änderungen vornehmen können. Oft wird das über eine spezielle URL wie zum Beispiel /admin/users/edit/5 geregelt. In CakePHP ist ein spezielles Adminrouting eingebaut. Es kann in der Kern-Konfigurationsdatei (core) aktiviert werden, indem man die Einstellung Routing.admin setzt:

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

Wenn Adminrouting aktiviert ist, werden Aktionen mit dem Präfix admin_ aufgerufen. Wird beispielsweise die URL /admin/users/edit/5 angefragt, dann wird die Methode admin_edit des UsersController mit 5 als Parameter aufgerufen.

Die URL /admin kann durch folgende Route an die admin_index Aktion des Pages Controller gebunden werden:

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

Es können auch multiple Präfixe verwendet werden:

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

Jede beliebige Anfrage an die URL ‚/Profiles/…‘ sucht nach profiles_ Präfixen im Methodenaufruf des Controllers. In unserem Beispiel würde die URL /profiles/users/edit/5 die Methode profiles_edit im UsersController aufrufen. Es ist sehr wichtig, dass der HtmlHelper benutzt wird um die Links zu erzeugen. Dann werden die Präfixaufrufe automatisch umgesetzt. Hier ein Beispiel wie die Links mit dem HtmlHelper generiert werden können:

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

Es können mehrere Routen mit Präfixen erstellt werden um eine flexible URL Struktur in der Anwendung zu erreichen.

Plugin routing¶

Plugin routing uses the plugin key. You can create links that point to a plugin by adding the plugin key to your url array.

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

Conversely if the active request is a plugin request and you want to create a link that has no plugin you can do the following.

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

By setting plugin => null you tell the Router that you want to create a link that is not part of a plugin.

Dateiendungen¶

Um verschiedene Dateiendungen mit den Routen verarbeiten zu können muss man folgende Extrazeile in der Routenkonfiguration hinzufügen:

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

Diese Zeile sagt dem Router, dass er alle passenden Dateiendungen entfernen und dann den Rest verarbeiten soll.

Wenn du eine URL wie zum Beispiel /page/name-der-seite.html erzeugen wolltest, dann würde man folgende Routen anlegen:

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

Um links zu erzeugen die zurück auf die Route zeigen, kann man einfach folgendes benutzen:

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

[STRIKEOUT:]