Introduzione alle Functions

Per questo motivo, Ector ha introdotto le functions, che sono delle funzioni eseguite a runtime e che permettono di inserire contenuti dinamici all'interno della configurazione del tema.

Una function è composta da due parti principali: la sua dichiarazione di utilizzo nella configurazione e la sua controparte nel codice.

Dichiarazione di Utilizzo

Per comunicare alla configurazione che un campo contiene una function, basta inserire la keyword function come chiave della proprietà e come valore la funzione da eseguire. Vediamo un esempio presente nella configurazione base, dentro IndexController -> carousel_product_1:

{
    "IndexController": {
        "carousel_product_1": {
            "title": "Prodotti in evidenza",
            "description": "Scopri i nostri prodotti in evidenza",
            "function": "idToProduct(product_ids)",
            "product_ids": [1, 2, 3, 4, 5]
        }
    }
}

In questa configurazione, abbiamo definito che carousel_product_1 debba eseguire una function chiamata idToProduct e che come parametro debba passare product_ids. Il nostro product_ids è un array di ID di prodotti che vogliamo visualizzare nel carosello.

Controparte nel Codice

Per creare una function eseguibile dalla configurazione, bisogna estendere l'hook hookActionEctorConfiguratorRegisterBlocks e registrare la funzione all'interno dei blocchi già esistenti.

public function hookActionEctorConfiguratorRegisterBlocks($params)
{
    $params["registeredBlocks"]["yourFunctionName"] = YourFunctionClass::class;
}

Consigliamo la creazione di un modulo dedicato per registrare le funzioni, in modo da non compromettere i file del modulo principale.

Creare la Function

Creare una function è semplice: basta creare una classe che estenda BlockFunctionAbstract e implementare il metodo build.

Ecco un esempio della funzione idToProduct:

<?php

namespace Dgcal\EctorConfigurator\Content\BlockFunction;

class IdToProduct extends BlockFunctionAbstract
{
    const IDENTIFIER = 'id_to_product_*';

    public function getIdentifier()
    {
        return self::IDENTIFIER;
    }

    public function isCacheable()
    {
        return false;
    }

    public function build()
    {
        $assembler = $this->getAssembler();
        $presenterFactory = $this->getPresenterFactory();
        $productPresenter = $presenterFactory->getPresenter();
        $content = $this->getContent();
        foreach ($content[$this->getPropKey()] as $k => $id) {
            $product = new \Product($id);
            if (!$product->id) {
                unset($content[$this->getPropKey()][$k]);
                continue;
            }
            $assembledProduct = $assembler->assembleProduct(['id_product' => $id]);
            $productArray = $productPresenter->present(
                $presenterFactory->getPresentationSettings(),
                $assembledProduct,
                $this->getContext()->language
            );
            $content[$this->getPropKey()][$k] = $productArray;
        }
        $this->setContent($content);
    }
}

La funzione riceve il contenuto della configurazione tramite il metodo getContent e il nome della proprietà che contiene i dati da elaborare tramite getPropKey. In questo caso, prende gli ID dei prodotti e li trasforma in un array di prodotti completi, che vengono poi passati alla configurazione.

Le Functions Esistenti

Ector mette a disposizione delle funzioni già pronte per l'utilizzo, che permettono di inserire contenuti dinamici in modo rapido e veloce:

• idToProduct: Trasforma gli ID dei prodotti in un array di prodotti completi.
• idToCategory: Trasforma gli ID delle categorie in un array di categorie complete.
• idToCategoryWithSubs: Trasforma gli ID delle categorie in un array di categorie complete, comprese di sottocategorie.
• idToBrand: Trasforma gli ID dei brand in un array di produttori completi.
• bestseller: Trasforma gli ID dei prodotti in un array di prodotti bestseller con informazioni essenziali.

Grazie a questo sistema, le opzioni di estensione sono infinite e la logica comune di passaggio e trasformazione dei dati può essere riutilizzata senza dover riscrivere tutto da capo.