Objekte filtern wie ein Profi – mit dem CoreShop Index Bundle

Was haben Klemmbausteine mit Pimcore zu tun? In vielen Pimcore-Projekten sollen Datenobjekte wie Produkte, Jobs oder Events nicht nur aufgelistet, sondern auch gezielt filterbar gemacht werden, z. B. nach Kategorien, Eigenschaften oder Relationen. Man sucht gezielt nach „dem passenden Teil“. Genau hier setzt das CoreShop Index Bundle an: Es ermöglicht das Indizieren beliebiger DataObjects und stellt leistungsfähige Filterfunktionen für Backend und Frontend bereit.

Was ist das CoreShop Index Bundle?

Das CoreShop Index Bundle erweitert Pimcore um eine strukturierte Möglichkeit, beliebige DataObjects zu indizieren und darauf aufbauend performante Filter- und Suchfunktionen umzusetzen.

Im Gegensatz zu klassischen Pimcore-Listenansichten, die direkt auf Objekten basieren, arbeitet das Bundle mit eigenen, optimierten Index-Tabellen in der Datenbank. Diese Tabellen lassen sich gezielt konfigurieren, z. B.:

• Welche Felder sollen indiziert werden?
• Soll ein Feld filter- oder sortierbar sein?

Die Vorteile dieser Architektur:

• Trennung von Datenmodell und Anzeige-/Filterlogik: mehr Flexibilität und Wartbarkeit
• Bessere Performance durch speziell strukturierte Datenbanktabellen
• Unterstützung für komplexe Anforderungen wie Relationen

Dank der vollständigen Integration ins Pimcore-Backend lassen sich auch komplexe Anwendungsfälle wie Produktlisten, Job-Übersichten oder Eventkalender schnell und effizient umsetzen, inklusive leistungsfähiger Filter.

Wie installiert man das Index Bundle?

Die Installation des CoreShop Index Bundles ist unkompliziert und folgt dem gewohnten Pimcore-Workflow. Die offizielle Dokumentation findest du hier: docs.coreshop.com/CoreShop/Bundles/Index_Bundle

1. Bundle via Composer installieren

Im Projektverzeichnis folgenden Befehl ausführen:

composer require coreshop/index-bundle:^4.0

2. Bundle in der Kernel.php registrieren

Füge das Bundle zur Bundle-Collection hinzu:

public function registerBundlesToCollection(BundleCollection $collection)
{
   …
   $collection->addBundles([
       new \CoreShop\Bundle\IndexBundle\CoreShopIndexBundle(),
   ]);
   …
}

3. Bundle installieren

Mit folgendem Konsolenbefehl wird das Bundle in Pimcore registriert, optional werden noch die Assets des Index Bundles nachinstalliert:

php bin/console pimcore:bundle:install CoreShopIndexBundle
# optional
php bin/console asset:install

Nach erfolgreicher Installation steht dir im Pimcore-Backend der Menüpunkt „CoreShop > Indices“ zur Verfügung. Damit kannst du direkt loslegen und Index-Definitionen und Filter konfigurieren.

Wie kann ich meine DataObjects jetzt indizieren?

Nach der Installation des Index Bundles kannst du beliebige Pimcore DataObjects für die Indizierung vorbereiten. Ziel ist es, strukturierte Index-Tabellen zu erstellen, auf denen du später performant filtern, sortieren und suchen kannst.

1. IndexableInterface implementieren

Damit Pimcore weiß, welche Objekte indiziert werden sollen, muss deine Klasse das IndexableInterface implementieren:

use CoreShop\Component\Index\Model\IndexableInterface;
use Pimcore\Model\DataObject\Concrete;
class Product extends Concrete implements IndexableInterface
{
    public function getIndexableEnabled(IndexInterface $index): bool
    {
        return true;
    }
    public function getIndexable(IndexInterface $index): bool
    {
        return $this->getPublished();
    }
    public function getIndexableName(IndexInterface $index, string $language): string
    {
        return $this->getName($language) ?? '';
    }
    ...
}

2. Index im Backend anlegen

Im Pimcore-Backend findest du unter „CoreShop > Indices“ die Möglichkeit, einen neuen Index zu definieren.

Wichtige Einstellungen dabei:

• Name: ein eindeutiger Name
• Klasse: die DataObject-Klasse, die indiziert werden soll
• Typ: der Index-Typ, CoreShop bietet hier out of the box eine MySQL-Implementierung an
• Felder: hier werden die Felder der Pimcore-DataObject-Klasse auf die Index-Felder gemappt

3. Felder konfigurieren

Für jedes Feld kannst du definieren:

• Name: Bezeichnung des Feldes im Index
• Getter-Klasse: wird benötigt, um den richtigen Wert für den Index abzurufen, wichtig z. B. für lokalisierte Felder oder Field Collections
• Interpreter: transformiert die Werte, bevor sie im Index gespeichert werden, z. B. um Relationen aufzulösen, Strings zu konvertieren oder Geo-Punkte umzuwandeln
• Typ: der Feldtyp im Index
• Getter-Konfiguration: manche Getter-Klassen haben eine eigene Konfiguration, z. B. um bei Field Collections das Feld anzugeben

4. (Optional) Interpreter verwenden

Falls du Daten aufbereiten, transformieren oder kombinieren willst (z. B. mehrere Felder zusammenführen), kannst du sogenannte Interpreter verwenden. Das sind kleine PHP-Klassen, die Werte transformieren, bevor sie indiziert werden.

CoreShop bringt ein Set an vorgefertigten Interpretern mit. Wie du eigene Interpreter definierst, steht im Kapitel „Wie kann ich eigene Interpreter anlegen?“.

Wie kann ich eigene Interpreter anlegen?

Eigene Interpreter sind sinnvoll, um Daten vor dem Speichern in den Index zu transformieren. Im folgenden Beispiel wird für eine Händlersuche das gerenderte Twig-Template eines Listeneintrags direkt im Index gespeichert.

Für eigene Interpreter gibt es eine Dokumentation von CoreShop. Grundsätzlich werden zwei Komponenten benötigt:

• ein FormType für die Eingabedaten
• der Interpreter selbst

Ein eigener Interpreter implementiert das Interface CoreShop\Component\Index\Interpreter\InterpreterInterface:

namespace App\CoreShop\Index\Interpreter;
use CoreShop\Bundle\ThemeBundle\Service\ThemeHelperInterface;
use CoreShop\Component\Index\Interpreter\InterpreterInterface;
use CoreShop\Component\Index\Model\IndexableInterface;
use CoreShop\Component\Index\Model\IndexColumnInterface;
use Pimcore\Model\DataObject\CoreShopCustomer;
use Twig\Environment;
class ListHtmlInterpreter implements InterpreterInterface
{
    public function __construct(
        protected Environment $templateEngine,
        protected ThemeHelperInterface $themeHelper,
    ) {
    }
    public function interpret(
        mixed $value,
        IndexableInterface $indexable,
        IndexColumnInterface $config,
        array $interpreterConfig = [],
    ): string {
        if (!$indexable instanceof CoreShopCustomer) {
            return '';
        }
        return $this->themeHelper->useTheme('cors/base', function () use ($indexable) {
            return $this->templateEngine->render('areas/retailer-search/include/list_entry.html.twig', ['location' => $indexable]);
        });
    }
}

Danach wird der Interpreter als Service registriert. CoreShop bringt bereits einen EmptyConfigurationFormType für eine Form ohne Konfigurationsmöglichkeiten mit. Im Backend gibt es für diesen Interpreter dann keine Einstellungen.

  App\CoreShop\Index\Interpreter\ListHtmlInterpreter:
    autoconfigure: false
    tags:
      - { name: coreshop.index.interpreter, type: listHtml, form-type: CoreShop\Bundle\IndexBundle\Form\Type\EmptyConfigurationFormType }

Wie kann ich Filter aufbauen und verwalten?

Sobald ein Index angelegt ist, lassen sich die indizierten Felder als Filter verwenden. Die Filter werden im Backend flexibel konfiguriert und verwaltet und ermöglichen eine strukturierte, performante Filterlogik für jede Art von Datensatz.

1. Filter im Backend anlegen

Im Pimcore-Backend findest du unter „CoreShop > Filter“ bzw. „CoreShop > Produkt > Filter“ eine Übersicht aller Filterkonfigurationen. Der Pfad hängt davon ab, ob nur das Index Bundle oder die komplette CoreShop Suite installiert ist.

Für eine Filterkonfiguration gibt es folgende Einstellungen:

• Name: Bezeichnung des Filters
• Index: der Index, auf den sich der Filter bezieht
• Sortierung: die Standard-Sortierreihenfolge
• Sortierungsfeld: das Feld, nach dem sortiert wird
• Ergebnisse pro Seite: Anzahl der Einträge pro Seite

2. (Pre) Conditions definieren

Im Backend lassen sich Pre Conditions, die vor den eigentlichen Conditions ausgeführt werden, und Conditions anlegen. Pre Conditions schränken die zu filternden Daten ein, bevor ein User einen Filter bedient. Das ist sinnvoll, wenn du etwa auf eine Kategorie vorfiltern willst.

Pre Conditions und Conditions legst du im Backend auf die gleiche Art an. CoreShop bietet ein Set an vordefinierten Filtern, zum Beispiel:

• Boolean
• (Relations-)Auswahl
• (Relations-)Mehrfachauswahl
• Range Slider
• Verschachtelte Bedingungen
• Kategorien
• Textsuche

Für jedes Feld wird ein Typ festgelegt, je Feld und Typ kommen dann die Einstellungen des jeweiligen Filtertyps dazu.

Reichen die mitgelieferten Filter nicht aus, lassen sich einfach eigene Filter erstellen. Eine genaue Anleitung dazu findest du in der CoreShop-Dokumentation.

Use Cases und Best Practices

Wir verwenden das CoreShop Index Bundle in beinahe jedem Projekt. Typische Szenarien sind Produktlisten, Job-Listings und Eventkalender mit facettierten Filtern nach Kategorien, Eigenschaften und Relationen. Durch die eigenen Index-Tabellen bleibt die Performance auch bei vielen Datensätzen stabil.

Einige unserer Projekte, die CoreShop Index & Filter verwenden:

• Rofima Produkte
• Sommerhuber Inspirationen
• Kwizda Agro Produkte
• Rübig Standorte
• Suzuki Pressemeldungen
• Büsscher & Hoffmann News

Best Practices

• Index-Felder gezielt und sparsam wählen und früh festlegen, was filter- und sortierbar ist.
• Für Relationen, lokalisierte Felder und Field Collections passende Getter und Interpreter konfigurieren.
• Eigene Interpreter schreiben, wenn komplexe Daten indiziert werden sollen.

Fazit: So einfach kann’s gehen

Composer-Install, Bundle registrieren, IndexableInterface implementieren, Index und Felder definieren, Filter im Backend anlegen: Schon lassen sich im Frontend performante, nutzerfreundliche Filter einsetzen.