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).

Übergebene Argumente¶

Übergebene Argumente sind zusätzliche Argumente oder Pfadteile, die beim Erstellen einer Anfrage häufig benutzt werden, um Parameter an die Controller-Methoden zu übergeben.

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

Im obigen Beispiel sind sowohl recent als auch mark übergebene Argumente an CalendarsController::view(). Es gibt insgesamt drei Möglichkeiten,auf zusätzliche Argumente im Controller zuzugreifen: Erstens als Argumente der aufgerufenen Action(-methode), zweitens über $this->params['pass'] (als numerisch indiziertes Array) oder drittens in $this->passedArgs in derselben Form wie in der zweiten Variante. Es ist über individuelle Routes auch möglich, bestimmte Parameter in „zusätzliche Argumente“ umzuwandeln, siehe passing parameters to an action für weitere Informationen dazu.

Argumente der aufgerufenen Action

CalendarsController extends AppController{
    function view($arg1, $arg2){
        debug($arg1);
        debug($arg2);
        debug(func_get_args());
    }
}

Das wird Folgendes ergeben:

recent

mark

Array
(
    [0] => recent
    [1] => mark
)

$this->params[‚pass‘] als numerisch indizierter Array

debug($this->params['pass'])

Das ergibt…

Array
(
    [0] => recent
    [1] => mark
)

$this->passedArgs als numerisch indiziertes Array

debug($this->passedArgs)

Array
(
    [0] => recent
    [1] => mark
)

$this->passedArgs kann auch benannte Parameter (engl. „named parameters“) enthalten, die sich dann in einem Array mit numerischen und nicht-numerischen Keys bemerkbar machen.

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

Benutzerdefinierte Routen definieren¶

Das Definieren eigener Routes erlaubt es, festzulegen, wie eine Applikation auf eine gegebene URL antwortet. routes werden in /app/config/routes.php über Router::connect() definiert.

Die Methode Router::connect() übernimmt bis zu drei Parameter: das abzugleichende URL-Muster, Vorgabewerte für die Elemente der neuen Route und REGEX-Regeln für einzelne Elemente der URL.

Das Grundgerüst einer Routedefinition siehte wie folgt aus:

Router::connect(
    'URL',
    array('Name eines Parameters' => 'Vorgabewert'),
    array('Name eines Parameters' => 'zugehöriges Muster')
)

Der erste Parameter teilt dem Router mit, auf welche URLs sich die neue Route beziehen soll. Die URL ist ein normaler, durch Schrägstriche eingerahmter String. Er darf jedoch durchaus Wildcards oder dynamische Elemente (Variablennamen mit einem Doppelpunkt gekennzeichnet) enthalten. Wildcards ermöglichen der Route, beliebig viele URLs eines Typs zu erfassen, während dynamische Elemente es ermöglichen, Paramter für die Controller-Actions zu extrahieren.

Die beiden letzteren Parameter von Router::connect() legen fest, was mit der Anfrage geschehen soll, wenn die Route auf die URL angewandt werden soll. Der zweite Parameter ist ein assoziatives Array, dessen Schlüssel nach den dynamischen Elementen in der URL oder nach Standardelementen (:controller, :action und :plugin) benannt sein sind. Die zugehörigen Werte sind die entsprechenden Vorgaben. Schauen wir uns einige einfache Beispiele an, bevor wir uns mit dem dritten Parameter von Router::connect() beschäftigen.

Router::connect(
    '/pages/*', //URL-Muster
    array('controller' => 'pages', 'action' => 'display')
    // Der Controller ist "pages" und die Action "display", was
    // hier nicht überschrieben werden kann
);

Genau diese Route befindet sich in routes.php Zeile 40, die mit CakePHP ausgeliefert wird (Standardroute). Sie wird auf alle URLs, die mit /pages/ beginnen, angewendet und ruft die display()PagesController()/pages/products würde beispielsweise zu Pagescontroller::display('products') aufgelöst werden.

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

Dieses zweite Beispiel zeigt eine exemplarische Verwendung des zweiten Parameters von Router::connect(), nämlich um Standardparameter festzulegen. Angenommen eine Seite bietet Produkte für verschiedene Kategorien von Kunden an. Dann bietet sich beispielsweise eine Route á la /government eher als/ als Ersatz zu /products/display/5 an.

Eine andere häufig genutzte Möglichkeit einer Route ist die Definition von Stellvertretern („Aliase“) für Controller. Sagen wir, statt der regulären URL /users/someAction/5 wollen wir den Zugriff über /cooks/someAction/5 vornehmen, dann lässt sich das ganz einfach mit Hilfe der folgenden Route lösen:

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

Das bewirkt, dass jede URL, die mit /cooks/ beginnt, an den Users-Controller weitergereicht wird.

Bei der Generierung von URLs werden Routes ebenfalls genutzt („Reverse Routing“). array('controller' => 'users', 'action' => 'someAction', 5) als URL wird zu /cooks/someAction/5 aufgelöst, sofern die obige Route die erste auf diese URL passende Route ist.

Sowohl beim Routing als auch beim Reverse Routing wird immer die erste „passende“ Route für die Auflösung/Generierung benutzt, d.h es empfiehlt sich, die speziellen/restriktiven Routen am Anfang und die allgemeinen Routen am Ende zu definieren, sodass eine allgemeine Route keine spezielle Route überdecken kann.

Wenn benutzerdefinierte dynamische benannte (engl. „named“) Argumente in einer Route benutzt werden, muß das dem Router über Router::connectNamed mitgeteilt werden. Wenn also in obiger Route URLs des Typs /cooks/someAction/type:chef erfasst werden sollen, wird das wie folgt realisiert:

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

Es ist möglich, eigene Elemente in der Route zu definieren. Dadurch ergibt sich die Möglichkeit, Stellen in der URL festzulegen, an denen Parameter für Controller-Actions liegen. Wenn eine Anfrage bearbeitet wird, finden sich die Werte dieser Elemente in $this->params des Controllers wieder. Dies steht im Gegensatz zu benannten Parametern: benannte Parameter (/controller/action/name:value$this->passedArgs oder auch $this->params['named'] angesprochen, wohingegen benutzerdefinierte Elemente nur über $this->params zugänglich sind. Wenn ein benutzerdefiniertes Element benutzt wird, muss auch ein regulärer Ausdruck hinzugefügt werden. Diese Information verwendet CakePHP zur Erstellung des mit der Route definierten Musters, welches wiederum zum Abgleich mit den URLs benötigt wird.

Die Trennung von benutzerdefinierten Elementen und benannten Parametern mag auf den ersten Blick verwirren. Benutzerdefinierte Elemente sind nichts Anderes als (script- aber nicht clientseitig benannte) positionsabhängige Argumente und auf sie wird daher über $this->params zugegriffen. Auf positionsabhängige, unbenannte Argumente greift man entweder direkt über die Funktionsargumente der Action zu oder über $this->params['pass'] oder $this->passedArgs Benannte Parameter hingegen sind nicht zwingend erforderlich (zumindest nicht für das Matching des Routers) und besitzen keine feste Position, daher werden sie über $this->passedArgs und $this->params['named'] übergeben. Es ist wichtig zu wissen, dass benutzerdefinierte Elemente im Gegensatz zu positionsabhängigen, unbenannten Argumenten nicht über $this->passedArgs, sondern nur über $this->params übergeben werden.

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

Dieses einfache Beispiel veranschaulicht, wie man schnell einen Weg ebnen kann, um Models von einem beliebigen Controller über eine URL des Typs /controllername/id zu betrachten. Die an Router::connect() übergebene URL definiert zwei Routen-Elemente: :controller und :id. Das Element :controller ist ein Standard-CakePHP-Routenelement, das den Router anweist, den dort befindlichen String als Controllernamen zu interpretieren. Das :id-Element ist ein benutzerdefiniertes Element und muss daher anschließend mit einem zugehörigen regulären Ausdruck im dritten Parameter von Router::connect() definiert werden. (CakePHP benötigt den regulären Ausdruck, um die ID von ihrer Umgebung unterscheiden zu können)

Mit dieser Route wird ein Zugriff auf /apples/5 zu apples/view/5. Beides ruft ApplesController::view() auf. Innerhalb dieser view()-Methode greift man auf die ID über $this->params['id'] oder auch $this->passedArgs['id'] zu.

Wenn nur ein einzelner Controller in der Applikation verendwet wird und aus Gründen der Einfachheit nicht in der URL auftauchen soll, sprich aus /home/demo soll /demo werden, dann könnte die Lösung etwa so aussehen:

Router::connect('/:action', array('controller' => 'home'));

Noch ein Beispiel:

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

Das ist schon eher kompliziert, zeigt aber seher anschaulich, wie mächtig Routes eingesetzt werden können. Die URL oben hat vier Routen-Elemente: Der erste kommt uns bekannt vor: Es ist ein Standard-Routenelement, das CakePHP als Controllername verwendet. Die anderen drei sind erst einmal nur dynamische Elemente der URL, auf die gleich noch Bezug genommen wird.

Als Nächstes werden einige Vorgabewerte definiert. Unabhängig vom Controller soll die *::index() Methode aufgerufen werden - also wird sie kurzerhand als Standard und nicht überschreibbar (da sie nicht in der URL auftaucht) definiert. Der Day-Parameter (deutsch: Tag), das vierte Element in der URL) wird per default auf null gesetzt und ist damit optional.

Zum Schluß werden einige reguläre Ausdrücke für die Jahre, Monate und Tage in numerischer Form festgelegt. Es ist anzumerken, dass Klammerung (Gruppierung) in diesen regulären Ausdücken nicht erlaubt ist.

Diese Route wird auf /articles/2007/02/01, /posts/2004/11/16 und /products/2001/05 angewandt (der Day-Parameter ist als optional definiert) und leitet die Anfragen an die index()-Actions der entsprechenden Controller weiter, wobei sie die Parameter u.a. in Controller::params['pass'] zur Verfügung stellt.

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, but 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:]

Custom Route classes¶

Custom route classes allow you to extend and change how individual routes parse requests and handle reverse routing. A route class should extend CakeRoute and implement one or both of match() and parse(). Parse is used to parse requests and match is used to handle reverse routing.

You can use a custom route class when making a route by using the routeClass option, and loading the file containing your route before trying to use it.

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

This route would create an instance of SlugRoute and allow you to implement custom parameter handling