Schwierigkeitsgrad: leicht
zu implementieren in: Model, View, Controller

Zunächst einmal sei erwähnt, dass es sicher auch andere Möglichkeiten gibt, diese Aufgabe zu lösen, doch ich denke diese Lösung ist einfach nachzuvollziehen und auch einfach selbst zu implementieren. Ihr solltet Euch mit dem Paginator ein wenig auskennen, das MVC Prinzip verstanden haben und ein wenig selber mitdenken können (aber sonst hättet Ihr auch den falschen Job, richtig?)

Fangen wir an mit dem Model, in das ich ein paar einfache Methoden eingebaut habe, um die entsprechenden Filteroptionen zu hinterlegen (sowas kann man selbstverständlich auch im Controller machen…). Wir gehen davon aus, dass unser zu paginierendes Model ‘Customer’ heißt.

im Model:

    public function getLimits() {
        return array(
            5 => __('5', true),
            10 => __('10', true),
            15 => __('15', true),
            20 => __('20', true),
            50 => __('50', true)
        );
    }

    public function getSortBies() {
        return array(
            'lastname' => __('Lastname', true),
            'firstname' => __('Firstname', true),
            'office' => __('Office', true),
            'email' => __('Email', true)
        );
    }

    public function getOrders() {
        return array(
            'ASC' => __('Ascending', true),
            'DESC' => __('Descending', true)
        );
    }

Bis hierhin eigentlich noch nichts spannendes. Hier werden lediglich die Arrays definiert, deren Inhalte wir nachher in den DropDowns der Filterliste wiedersehen werden. Wie gesagt, man kann das auch im Controller definieren, aber das würde dem Prinzip von ‘Fat Models, Skinny Controllers’ widersprechen, was als Best-Practice bei Cake (und anderen MVC-Frameworks natürlich auch!) gilt…

Als nächstes nehmen wir uns das View vor, um dem User die entsprechenden Filtermöglichkeiten anzubieten. Hier setzt ihr einfach da wo es euch paßt folgendes ein:

im View:

<div class="filter_container">
<?php echo $form->create('Customer', array('action' => 'index'));?>
	<fieldset>
 		<legend><?php __('Filter Options');?></legend>
	<?php
		echo $form->input('Customer.limit', array(
            'selected' => $session->read('Customer.limit')
        ));
        echo $form->input('Customer.sortby', array(
            'selected' => $session->read('Customer.sortby')
        ));
        echo $form->input('Customer.order', array(
            'selected' => $session->read('Customer.order')
        ));
	?>
	</fieldset>
<?php echo $form->end('Submit');?>
</div>

An sich ist auch das hier alles wie immer bei Cake. Auffallend ist hier der zugewiesene ’selected’ Wert, der gesetzt wird sollte für das Model Customer der entsprechende Filterschlüssel bereits in der Session hinterlegt sein. Die Form wird an die index-action gesendet, welche dann die übergebenen Parameter auswertet und den Paginator entsprechend verändern wird. Hierzu gleich mehr im Controller-Teil.

Ich habe mich für den Weg über die Sessions entschieden, da ich kein Freund von unnötigen GET-Parametern bin und die Session für persönliche Einstellungen genutzt werden darf. Wer Lust hat, kann das Ganze auch als Cookie hinterlegen, oder sogar als eine Art permanent-setting in der Datenbank speichern. Der Kreativität sind dabei keine Grenzen gesetzt!

Ist das View erledigt, folgt noch der Controller. Hier werden wir übergebene Werte in die Session schreiben, die Variablen des Paginators zuweisen und dem View unsere im Model hinterlegten Drop-Down Arrays zur Verfügung stellen. Zunächst aber hier einmal des gesamte Code:

im Controller:

public function index() {
        if(!empty($this->data['Customer']['limit'])) {
            $this->Session->write('Customer.limit', $this->data['Customer']['limit']);
        }
        if(!empty($this->data['Customer']['order'])) {
            $this->Session->write('Customer.order', $this->data['Customer']['order']);
        }
        if(!empty($this->data['Customer']['sortby'])) {
            $this->Session->write('Customer.sortby', $this->data['Customer']['sortby']);
        }
        $limit = $this->Session->read('Customer.limit');
        $order = $this->Session->read('Customer.order');
        $sortby = $this->Session->read('Customer.sortby');

        if(empty($limit)) {
            $limit = 10;
        }
        if(empty($order)) {
            $order = 'ASC';
        }
        if(empty($sortby)) {
            $sortby = 'lastname';
        }
        $this->paginate['Customer'] = array(
            'contain' => false,
            'conditions' => array(
                'Customer.deleted' => 0,
            ),
            'limit' => $limit,
            'order' => array(
                'Customer.'.$sortby => $order
            )
        );
        $limits = $this->Customer->getLimits();
        $orders = $this->Customer->getOrders();
        $sortbies = $this->Customer->getSortbies();
        $professors = $this->paginate('Customer');
        $this->set(compact('customers', 'limits', 'orders', 'sortbies'));
}

Was passiert hier also?
Wir checken ob uns das Filter-Formular Daten gesendet hat, sprich ob der Benutzer Filter eingestellt und dann abgeschickt hat. Wenn es Daten gibt, dann werden sie in die Session geschrieben. Danach werden die Session-Daten wieder ausgelesen, und danach geprüft ob wirklich Daten vorhanden sind. Benutzt man die Action zum ersten Mal nach dem Login, gibt es ja noch keine Daten in der Session, also muss man dafür sorgen, dass Standardwerte übernommen werden. Das geschieht im folgenden Teil.
Danach wird der Paginator customized angelegt. Dieser Weg ist besonders dann von Vorteil, wenn man in einem Controller mehrmals verschiedenen “verseiten” muss. Man hat somit einfach eine klarere und bessere Eingriffsmöglichkeit, als wenn man dies am Anfang des Controller über var $paginate tuen würde.

Als letztes werden die Variablen für die DropDowns aus dem Model gelesen, und dem View über $this->set() zur Verfügung gestellt.

Das wars auch schon. Ihr habt jetzt eine Paginierung mit Filtermöglichkeiten, die sich während der gesamten Session speichert und dem Benutzer so eine bessere Möglichkeit der Eingrenzung und Filterung bietet.

Da ich absichtlich das Model mittels Punktnotation in der Session abgelegt habe, kann für jedes Model in jedem Controller und in jeder Action eine eigene Filterung angeboten werden. Ganz coole Leute bringen sowas wahrscheinlich in einer gekapselten Component unter, was ich evtl. in den nächsten Wochen nachholen werde.

Viel Spaß beim PAGINIEREN

… so nach einer ganzen Weile melde ich mich endlich mal wieder hier zu Wort. Es gab sehr viel zu tun in letzter Zeit, angefangen von einer ganzen Menge Arbeit um die Finanzen wieder in einem etwas helleren Licht erstrahlen zu lassen, andererseits aber auch die Prüfungsphase Ende September, in der ich mich mit Signaltheorie, Mathematik und Algorithmen & Datenstrukturen beschäftigt habe. Auf die Ergebnisse werde ich wohl noch etwas warten müssen, aber nun kann ich denke ich mit Recht behaupten es geht in die letzte Phase des Studiums. Es sind nicht mehr viele Prüfungen übrig, und auch diese werde ich in den kommenden Monaten bestehen.

Nun zurück zu Wushu…
Ich habe zwar den Hauptartikel (zum Hauptsystem) der Wushu-Restaurant-Website immernoch nicht verfaßt, dennoch wollte ich hier kurz zumindest die aktuelle Erweiterung ansprechen. Wie immer kam der Auftrag von Digital Cube und es war wie immer angenehm und erfolgreich was die Zusammenarbeit betrifft. Neben der bekannten (jaja, Artikel folgt… ;( ) Funktionalität bekam das beliebte Restaurant mit Sitz in Barcelona nun die Möglichkeit, über das von uns entwickelte individuelle Content Management System sog. “Cooking Classes” hinzuzufügen. Dies bedeutet, dass
das Restaurant eigene Videos, welche auf der Website mit dem sog. “Slideshow-Pro”-Plugin dargestellt werden, einfügen kann nebst eines selbst angelegten Textes, z.B. ein Rezept. Zusätzlich wurde ein einfaches Kategoriesystem eingebaut, welches es ermöglicht die Rezepte zu verschiedenen Themengebieten zusammen zu fassen.

Die Erweiterung wurde nahtlos in das bestehende Backend eingefügt und ebenso wie die anderen Inhalte werden dauch die neuen Artikel in 3 Sprachen gleichzeitig gespeichert. Inhalte können hinzugefügt, editiert und gelöscht werden, und auch der Status kann von online auf offline geschaltet werden um einen Eintrag kurzfristig aus dem Frontend zu entfernen, ohne ihn gleichzeitig komplett aus der Datenbank löschen zu müssen.

Alles in allem eine runde Sache, wobei auch die Geschwindigkeit des Backends durchaus zu überzeugen weiß. Hier gibt es im Grunde keine erkennbaren Ladezeiten, was die Leute bei Wushu freuen dürfte. Und für einen Entwickler gibt es kaum etwas schlimmeres als ewig lange Ladezeiten !

Ich wünsche dem Wushu-Team daher weiterhin viel Erfolg und Spaß mit den neuen Komponenten!

Durch einen Zufall entdeckte ich heute eine komische Eigenart von Email-Servern und/oder Clients, wenn es um den Absender einer Email geht. Angenommen wir möchten als Absender nicht die Email-Adresse alleine, sondern einen netten Text erscheinen lassen, dann reicht es dummerweise nicht, folgendes zu tun:


$this->Email->from = "Netter Text";


sondern man MUSS zwingend noch eine Emailadresse angeben, und zwar in dieser Form:


$this->Email->from = "Netter Text <email@mail.com>";


Klingt komisch, ist aber so!