Pimcore stellt eine komfortable Möglichkeit zur Verfügung, einer Webseite eine strukturierte Dokumentenhierarchie zu verleihen.
Diese Struktur kann automatisiert ausgelesen und sowohl in eine Navigation für die Webseite selbst als auch in sinnvolle und “sprechende” URLs verarbeitet werden.
So ist die URL zu einer Seite “Impressum” folgerichtig “/impressum”, und falls die Seite in einem Unterverzeichnis steckt dann “/unterverzeichnis/impressum”.

Häufiger hatten wir hier das Problem, dass auf der Webseite mehrere, voneinander getrennte Navigationen gewünscht sind. Diese kann man in Pimcore dann ganz leicht in Unterordnern zusammenfassen und jeden individuell auslesen und in eine Navigation verwandeln. Dies stellt aus Suchmaschinensicht aber nicht das Optimum dar, da mit jedem Unterpfad die Relevanz der Seite sinkt, von der “merkwüdigen” URL wie “/kopfnavigation/impressum” ganz zu schweigen.

Wir haben daher mit Hilfe der Eigenschaften, die in Pimcore jeder Seite vergeben werden können, eine Lösung entwickelt.

Folgende Ausgangssituation:

Es existieren drei Navigationen:

1. Die Kopfnavigation
2. Die Linke Navigation
3. Die Hauptnavigation

Zudem gibt es im Fuß der Seite die Gesamtnavigation in der jeder mögliche Navigationspunkt nochmal aufgeführt ist:

In Pimcore sind diese Seiten in einer flachen Hierarchie untergebracht, um möglichst kurze URLs zu produzieren:

In der Umsetzung bedienen wir uns der Zend_Navigation, welche uns sehr viel Arbeit abnimmt.
Mit dem pimcoreNavigation() View Helper stellt uns Pimcore eine komfortable Möglichkeit zur Verfügung, eine fertige Zend_Navigation aus dem Dokumentenbaum zu erzeugen.
Dies erreicht man durch Aufrufen der Methode getNavigation($currentDocument, $navStartNode) des View Helpers. $currentDocument stellt dabei das Dokument dar, das in der Navigation als “aktiv” markiert werden soll. In unserem Zusammenhang ist das $this->document. Die Variable $navStartNode beschreibt das Dokument, dessen Kinder die einzelnen Links werden. In unserem Fall ist das “/home”.

      $navStartNode = Document::getById(1);
      $gesamte_nav = $this->view->pimcoreNavigation()->getNavigation($this->document, $navStartNode);

Aus dieser Navigation erzeugen wir nun die anderen, wir müssen jeder Seite nur noch die Information mitgeben, in welcher Navigation sie zusätzlich noch erscheinen soll.
Dies erreichen wir mit den Eigenschaften der Seite. Praktisch hierfür ist es, eine vorgefertige Eigenschaft zu definieren, aus der dann nur noch ausgewählt werden muß. Hier ist das eine “select” Eigenschaft mit den Werten “Kopf,Links,Haupt”:

Diese Eigenschaft kann man nun jeder Seite zuweisen:

Diese Information kann nun bequem ausgewertet werden, um die einzelnen Navigationen zu erzeugen.
Hierbei lesen wir jede Zend_Navigation_Page aus der Navigation aus und werten die Eigenschaft “navigation” des Documents der Page aus. Abhängig vom Inhalt wird eine Seite gegebenenfalls einer weiteren Navigation zugewiesen:

      $kopf_nav  = new Zend_Navigation();
      $linke_nav = new Zend_Navigation();
      $haupt_nav = new Zend_Navigation();

      foreach ($gesamte_nav as $page) {
        $newpage = clone $page;
        $nav_property = trim($page->getDocument()->getProperty("navigation"));
        if     ($nav_property == "Kopf")  $kopf_nav->addPage($newpage);
        elseif ($nav_property == "Haupt") $haupt_nav->addPage($newpage);
        elseif ($nav_property == "Links") $linke_nav->addPage($newpage);
      }

      $this->view->gesamte_nav = $gesamte_nav;
      $this->view->kopf_nav    = $kopf_nav;
      $this->view->linke_nav   = $linke_nav;
      $this->view->haupt_nav   = $haupt_nav;

Ganz wichtig hierbei ist es, $page vor der Zuweisung durch addPage() mit dem clone keywords zu kopieren (Zeile 6), da Zend_Navigation_Container der Seite beim addPage()-Vorgang ein neues Parent zuweist und damit der Gesamt-Navigation entziehen würde.

Die so erzeugten Navigationen können im Layout nun bequem ausgegeben werden:

echo $this->navigation()->menu()->renderMenu($this->kopf_nav, array("maxDepth" => 0));

Für ein Webformular brauchten wir wir eine Zend Framework Selectbox mit den validen Sprachen des Frontends.

Pimcore bietet auch hier wieder komfortable Möglichkeiten, die aktuell im Backend eingestellten Sprachen zu verarbeiten.

Das ganze Problem wird hierdurch wieder mal zum komfortablen Fünfzeiler wenn man weiß wo man hinfassen muss.

Pimcore liefert mit der statischen Methode Pimcore_Tool::getValidLanguages() einen Array an Kürzeln der validen Sprachen, also zB array(“de”, “en”).

Dies kann man sich nun noch vom Zend Framework übersetzen lassen, ebenfalls mit einer statischen Methode: Zend_Locale::getTranslation($kuerzel, “language”, $zielsprache).
Sinnvollerweise lässt man sich das Kürzel in die Sprache übersetzen, die es repräsentiert – ein auswählender User kann seine Sprache damit sicher identifizieren.

Der Select-Viewhelper erwartet nun noch die Werte im Format array($value => $label).

Zusammengefasst sieht das daher dann so aus:

$pimcore_languages = Pimcore_Tool::getValidLanguages();
$languages = array();
foreach ($pimcore_languages as $lang) {
  $languages[$lang] = Zend_Locale::getTranslation($lang, 'language', $lang);
}
$language = $this->createElement("select", "language");
$language->setLabel("Sprache")
         ->setMultioptions($languages);

Wieder mal ein Griff in die Trickkiste, aus der Kategorie “nützliche Dreizeiler”.

Problemstellung war ein Kontaktformular mit einem Dropdown als Liste aller Länder.

Man kann diese Liste nun natürlich “zu Fuss” definieren, oder sich gleich komfortabel von Pimcore bzw dem Zend Framework befüllen lassen – dort liegen die Daten ohnehin schon vor:

    $countries = new Object_Class_Data_Country();
    $options = array();
    foreach ($countries->getOptions() as $country) $options[$country["value"]] = $country["key"];

Im Array $options liegen die Länder dann in der Form vor, wie man sie direkt in ein Zend Form Element vom Typ Select stecken kann:

    $land = $this->createElement("select", "land");
    $land->setLabel("Land")->setMultioptions($options);

Wer ein spezielleres Ergebnis braucht, kann die Erstellung auch selbst vornehmen und das abändern bzw kopieren, was in Object_Class_Data_Country gemacht wird:

        $countries = Zend_Locale::getTranslationList('territory');
        asort($countries);
        $options = array();

        foreach ($countries as $short => $translation) {
            if (strlen($short) == 2) {
                $options[] = array(
                    "key" => $translation,
                    "value" => $short
                );
            }
        }

        return $options;

Die mit dem Zend Forms gebauten Formulare lassen sich bekanntlich mit Validatoren ausstatten, die bei einer Regelverletzung eine entsprechende Fehlermeldung ausgeben.
Diese lässt sich, mit einigem Aufwand, internationalisieren.

Pimcore liefert einen komfortablen Übersetzungs-Manager mit, den man für seine eigenen Zwecke verwenden kann – dieser lässt sich auch mit Zend Forms verbinden!

Dies geschieht mit ein paar einfachen Schritten, hier exemplarisch in Verbindung mit einem durch Alexandre Delattres Form Builder Plugin erzeugten Form:

$formbuilder = new Formbuilder_Frontend();
$form = $formbuilder->getForm("kontakt");
		
$locale = Zend_Registry::get("Zend_Locale");
$translate = new Pimcore_Translate($locale);
$form->setTranslator($translate);
$form->setDefaultTranslator($translate);

Mit diesem Code-Konstrukt landen nun alle Strings, die das Form ausgibt, im Übersetzer und können bearbeitet werden. Praktischerweise wird die noch nicht Variablen-bereinigte Version in die Liste eingestellt, so dass eine kontextbezogene Anpassung der Übersetzungen möglich ist.

Gegebenenfalls muss in der Zend-Registry noch die benötigte Locale hinterlegt werden.

Dies kann zum Beispiel in website/lib/Website/Controller/Action.php erfolgen:

try {
  $locale = Zend_Registry::get("Zend_Locale");
} catch (Exception $e) {
  $locale = new Zend_Locale("de");
  Zend_Registry::set("Zend_Locale", $locale);
}

Dies nur beispielhaft für Deutsch, bei einer Verwendung mit mehreren Sprachen muss hier natürlich flexibler Code verwendet werden.