# Disattivare una combinazione in PrestaShop 9.2 senza cancellarla

> Pubblicato: 2026-10-31

Un caso d'uso delle proprietà aggiuntive di PrestaShop 9.2: un interruttore sulla combinazione e un piccolo modulo che la rende non acquistabile nel negozio.

Immagine creata con AI

In PrestaShop un prodotto si può disattivare, una sua combinazione no. Se la t-shirt rossa in taglia M esce di produzione per una stagione, hai due strade: la cancelli, e perdi riferimenti, immagini e storico, oppure la lasci a giacenza zero e speri che nessuno la ordini con l'acquisto in esaurimento attivo. Con PrestaShop 9.2 c'è una terza via: le [proprietà aggiuntive](https://devdocs.prestashop-project.org/9/development/components/extra-properties/), che funzionano anche sulle combinazioni.

In questo articolo ho messo insieme un caso d'uso completo: un campo "Combinazione spenta" creato dal back office, senza codice, e un modulo di poche righe che nel negozio rende la variante non acquistabile. Come si crea una proprietà e come si mostra nel tema l'ho spiegato, con il video, nell'[articolo sulle proprietà aggiuntive di PrestaShop 9.2](/articoli/proprieta-aggiuntive-prestashop-9-2-come-crearle-e-mostrarle). Qui vado dritto sulle combinazioni.

&lt;InfoBox content="Ti serve spegnere varianti senza cancellarle, o portare un altro dato del tuo gestionale sulle combinazioni? Lo progettiamo con le proprietà aggiuntive di PrestaShop 9.2, senza override. <a href='/contattaci'&gt;Scrivici&lt;/a&gt;." />

In questo articolo

- [Cosa vogliamo ottenere](#cosa-vogliamo-ottenere)
- [Il campo nel back office](#il-campo-nel-back-office)
- [Il modulo che spegne la combinazione](#il-modulo-che-spegne-la-combinazione)
- [Installare e provare](#installare-e-provare)
- [Limiti da conoscere](#limiti-da-conoscere)
- [Domande frequenti](#domande-frequenti)

## Cosa vogliamo ottenere

L'obiettivo è semplice da dire. Nella finestra di modifica della combinazione c'è un interruttore. Quando è acceso, nel negozio la variante resta visibile ma non si compra: il pulsante "Aggiungi al carrello" è disattivato e al posto della disponibilità compare "Questa variante non è disponibile". Se qualcuno prova lo stesso ad aggiungerla, per esempio con una richiesta fatta a mano, il carrello la rifiuta.

Per arrivarci servono due pezzi:

1. una proprietà aggiuntiva di tipo booleano sull'entità `combination`, creata da Parametri avanzati, Proprietà aggiuntive;
2. un modulo che legge quel valore e interviene in due punti: la pagina prodotto e il carrello.

Ho preso i nomi delle classi, degli hook e dei parametri dal codice di PrestaShop 9.2.0, dalla documentazione per sviluppatori e dal modulo di esempio ufficiale [demoextraproperty](https://github.com/PrestaShop/example-modules/tree/master/demoextraproperty), che registra anche lui proprietà sulle combinazioni.

## Il campo nel back office

La proprietà la crea chi gestisce il negozio, senza toccare codice. Le proprietà create da qui appartengono al core: nel codice si leggono sotto la chiave `_core`, e questo nome servirà al modulo. La pagina è descritta nella guida ufficiale [Manage extra properties from the Back Office](https://devdocs.prestashop-project.org/9/development/components/extra-properties/register-from-back-office/).

Vai in Parametri avanzati, Proprietà aggiuntive e premi "Aggiungi una nuova proprietà aggiuntiva". Il modulo ha cinque riquadri. Ti scrivo i valori da inserire uno per uno.

### Definizione del campo

- **Nome entità**: `combination`. PrestaShop accetta anche `product_attribute`, che è il nome della tabella: le due scritture finiscono nello stesso posto.
- **Nome proprietà**: `combinazione_spenta`. Solo lettere, cifre e trattini bassi. Diventa il nome della colonna nella tabella `product_attribute_extra`.
- **Tipo di campo**: booleano. Nel database è un `TINYINT(1)` e nel back office diventa un interruttore sì/no.
- **Ambito**: comune, cioè un solo valore per combinazione. Se hai più negozi e vuoi spegnere la variante solo in uno, scegli "per negozio": il codice del modulo non cambia, perché il valore letto è già quello del negozio corrente.
- **Indice SQL**: nessuno va bene. Mettilo se pensi di fare query o report sulle combinazioni spente.
- **Nullable**: no.
- **Valore predefinito**: 0. Le combinazioni che esistono già partono accese, e lo stesso vale per quelle nuove.

Nome entità, nome proprietà, tipo, ambito e valore predefinito non si cambiano dopo il salvataggio. Conviene sceglierli bene la prima volta.

### Visibilità

- **Visualizza in front-office**: sì. Questa è la spunta che fa funzionare tutto. Nel negozio PrestaShop carica solo le proprietà con questa opzione attiva: senza, il modulo leggerebbe sempre un valore vuoto e non spegnerebbe niente.
- **Obbligatorio**: no. Su un interruttore "obbligatorio" vorrebbe dire acceso per forza.

### Etichette e descrizioni

- **Etichetta**: "Combinazione spenta", con un dominio di traduzione del back office, per esempio `Admin.Catalog.Feature`. L'etichetta è obbligatoria quando il campo va in un modulo.
- **Descrizione**: una frase che compare sotto il campo, per esempio "Se attivo, la variante resta in catalogo ma non si può acquistare".

### Convalida

Nessun vincolo. Il controllo del tipo lo fa PrestaShop comunque: un booleano accetta solo vero o falso.

### Posizionamento

- **Moduli (forms)**: scegli `combination_form`, cioè il modulo di modifica della combinazione. Con la posizione automatica il campo va in fondo alla finestra. Se vuoi spostarlo, puoi indicare un campo esistente e mettere il tuo prima o dopo.
- **Griglie**: niente. L'elenco delle combinazioni dentro la pagina prodotto non è una griglia del back office, quindi non c'è dove agganciarlo.
- **Admin API**: facoltativo. Se un gestionale o un ERP deve accendere e spegnere le varianti da solo, aggiungi l'operazione `/products/{productId}/combinations`, la stessa che usa il modulo di esempio ufficiale.
- **Tipo di modulo Symfony**: lascialo vuoto. Per un booleano PrestaShop usa già l'interruttore (`SwitchType`).

Salva. Da questo momento, in Catalogo, Prodotti, scheda Combinazioni, quando apri una combinazione con la matita trovi in fondo l'interruttore "Combinazione spenta". Il valore si salva insieme agli altri campi della combinazione.

## Il modulo che spegne la combinazione

Il campo da solo non fa niente: è un dato salvato. Il comportamento nel negozio lo decide un modulo. Il mio fa tre cose:

1. legge il valore del campo per una combinazione;
2. sulla pagina prodotto, se la combinazione scelta è spenta, disattiva il pulsante e cambia il messaggio di disponibilità;
3. nel carrello rifiuta l'aggiunta di una combinazione spenta.

Il modulo si chiama `bwcombinazionispente` e sta in un solo file, `modules/bwcombinazionispente/bwcombinazionispente.php`.

```php
<?php

declare(strict_types=1);

use PrestaShop\PrestaShop\Adapter\Presenter\Product\ProductLazyArray;

if (!defined('_PS_VERSION_')) {
    exit;
}

class Bwcombinazionispente extends Module
{
    /** Proprietà creata dal back office: appartiene al core, chiave '_core'. */
    private const OWNER = '_core';
    private const PROPERTY = 'combinazione_spenta';

    /** @var array<int, bool> */
    private array $switchedOff = [];

    public function __construct()
    {
        $this->name = 'bwcombinazionispente';
        $this->tab = 'front_office_features';
        $this->version = '1.0.0';
        $this->author = 'bwlab';
        $this->need_instance = 0;
        $this->ps_versions_compliancy = ['min' => '9.2.0', 'max' => '9.99.99'];

        parent::__construct();

        $this->displayName = $this->trans('Combinazioni spente', [], 'Modules.Bwcombinazionispente.Admin');
        $this->description = $this->trans(
            'Rende non acquistabili le combinazioni con la proprietà "combinazione_spenta" attiva.',
            [],
            'Modules.Bwcombinazionispente.Admin'
        );
    }

    public function isUsingNewTranslationSystem(): bool
    {
        return true;
    }

    public function install(): bool
    {
        return parent::install()
            && $this->registerHook('filterProductContent')
            && $this->registerHook('actionFrontControllerInitAfter');
    }

    /**
     * Pagina prodotto: se la combinazione mostrata è spenta,
     * niente pulsante di acquisto e messaggio di non disponibilità.
     */
    public function hookFilterProductContent(array $params): array
    {
        $product = $params['object'] ?? null;
        if (!$product instanceof ProductLazyArray) {
            return $params;
        }

        if (!$this->isSwitchedOff((int) $product['id_product_attribute'])) {
            return $params;
        }

        // add_to_cart_url è calcolato da un metodo del LazyArray:
        // per sovrascriverlo serve il terzo parametro $force.
        $product->offsetSet('add_to_cart_url', null, true);
        $product['availability'] = 'unavailable';
        $product['availability_message'] = $this->unavailableMessage();

        return ['object' => $product];
    }

    /**
     * Carrello: blocca l'aggiunta di una combinazione spenta
     * prima che CartController la elabori.
     */
    public function hookActionFrontControllerInitAfter(array $params): void
    {
        $controller = $params['controller'] ?? null;
        if (!$controller instanceof CartController) {
            return;
        }

        // Si blocca solo chi aggiunge: togliere o diminuire resta sempre possibile.
        $isAdding = Tools::getIsset('add')
            || (Tools::getIsset('update') && 'down' !== Tools::getValue('op', 'up'));
        if (!$isAdding) {
            return;
        }

        $idProduct = (int) Tools::getValue('id_product');
        $idProductAttribute = (int) Tools::getValue('id_product_attribute', Tools::getValue('ipa'));

        // Dalla pagina prodotto arrivano anche gli attributi scelti: vincono loro,
        // come in CartController::processChangeProductInCart().
        $group = Tools::getValue('group');
        if ($idProduct > 0 && is_array($group) && [] !== $group) {
            $idProductAttribute = (int) Product::getIdProductAttributeByIdAttributes($idProduct, $group);
        }

        if ($this->isSwitchedOff($idProductAttribute)) {
            $controller->errors[] = $this->unavailableMessage();
        }
    }

    private function isSwitchedOff(int $idProductAttribute): bool
    {
        if ($idProductAttribute <= 0) {
            return false;
        }

        if (!isset($this->switchedOff[$idProductAttribute])) {
            $combination = new Combination($idProductAttribute);
            $this->switchedOff[$idProductAttribute] = Validate::isLoadedObject($combination)
                && (bool) $combination->extra_properties[self::OWNER][self::PROPERTY];
        }

        return $this->switchedOff[$idProductAttribute];
    }

    private function unavailableMessage(): string
    {
        return $this->trans('Questa variante non è disponibile.', [], 'Modules.Bwcombinazionispente.Shop');
    }
}
```

Ora lo smonto pezzo per pezzo.

### Leggere il valore

Ogni `ObjectModel` di PrestaShop 9.2 ha un contenitore `extra_properties`, caricato solo al primo accesso. I valori sono raggruppati per proprietario e poi per nome, quindi per una proprietà creata dal back office si scrive:

```php
$combination->extra_properties['_core']['combinazione_spenta'];
```

Se il campo fosse stato registrato da un modulo, al posto di `_core` ci sarebbe il nome del modulo, come nel modulo di esempio ufficiale con `$product->extra_properties['demoextraproperty']['is_dangerous']`.

Una chiave che non esiste non genera errori: il contenitore restituisce `null`. Per questo il cast a `bool` basta anche quando la proprietà non c'è o non è visibile nel front office. I risultati li tengo in un array del modulo, così ogni combinazione si legge una volta sola per richiesta.

### La pagina prodotto: filterProductContent

Il `ProductController` di PrestaShop 9.2 prepara il prodotto da passare al tema e poi lo fa passare dall'hook `filterProductContent`. È un hook a catena: ogni modulo riceve `['object' => $product]` e deve restituire un array con la stessa forma, che passa al modulo successivo.

`$product` è un `ProductLazyArray`. Leggo `id_product_attribute`, che è la combinazione mostrata in quel momento, e se è spenta cambio tre valori:

- `add_to_cart_url` a `null`: nel tema Hummingbird il pulsante "Aggiungi al carrello" ha l'attributo `disabled` quando questo valore è vuoto. Visto che il valore viene da un metodo della classe, una normale assegnazione solleverebbe un'eccezione: `offsetSet()` con il terzo parametro a `true` è il modo previsto dal core per forzarla;
- `availability` a `unavailable`: il tema mostra l'icona rossa;
- `availability_message` con il testo che vede il cliente.

Quando il cliente cambia taglia o colore, il tema chiede al server di aggiornare la pagina. Quella richiesta ripassa da `initContent()` e quindi dallo stesso hook: pulsante e messaggio si aggiornano anche senza ricaricare la pagina.

### Il carrello: actionFrontControllerInitAfter

Disattivare il pulsante non basta: una richiesta al carrello si può costruire a mano. Il blocco vero sta nel `CartController`.

`FrontController::init()` chiama alla fine l'hook `actionFrontControllerInitAfter` e gli passa il controller. Subito dopo, il `CartController` elabora l'aggiunta solo se la sua lista `errors` è vuota. Se il modulo ci mette un messaggio, l'aggiunta non parte e la risposta AJAX al tema contiene l'errore.

Il modulo ricava la combinazione come fa il carrello: prima `id_product_attribute` (o `ipa`), poi, se arrivano gli attributi scelti in `group`, la combinazione corrispondente con `Product::getIdProductAttributeByIdAttributes()`. Il controllo vale solo per chi aggiunge: chi toglie o diminuisce una quantità deve poterlo fare sempre, anche su una variante spenta che era già nel carrello.

## Installare e provare

1. Crea la cartella `modules/bwcombinazionispente/` e mettici il file. Per la prova basta questo; un modulo da distribuire avrà anche il logo e il resto della struttura standard.
2. Installa il modulo da Moduli, Gestione moduli.
3. Prima di spegnere, metti nel carrello la combinazione che userai per la prova.
4. Apri il prodotto nel back office, scheda Combinazioni, modifica quella combinazione e accendi "Combinazione spenta". Salva.
5. Nel negozio scegli la combinazione: il pulsante è disattivato e compare "Questa variante non è disponibile".
6. Vai nel carrello e aumenta la quantità della stessa combinazione con il pulsante +: il carrello risponde con l'errore. Il pulsante − invece funziona, e la variante si può togliere.

Se la combinazione spenta è anche quella predefinita, il cliente arriva sulla pagina e trova subito una variante non acquistabile. Conviene mettere come predefinita una combinazione accesa.

## Limiti da conoscere

**La variante resta nel selettore.** Il modulo la rende non acquistabile, non la nasconde. Nel `ProductController` di PrestaShop 9.2 l'elenco dei gruppi di attributi si costruisce in `assignAttributesGroups()`, che non ha un hook per filtrarlo. Nasconderla del tutto vuol dire intervenire nel JavaScript del tema o scrivere un override del controller. Si può fare, ma porta via le garanzie che ci dà un modulo che usa solo hook.

**La vista rapida non ripassa dal filtro.** L'anteprima del prodotto aperta dalla categoria usa un percorso del controller che non chiama `filterProductContent`: lì il pulsante resta attivo. Il blocco del carrello però vale anche lì, e il cliente riceve l'errore.

**Il carrello già pieno.** Se spegni una variante che qualcuno ha già nel carrello, il modulo non la toglie e non ferma l'ordine. Se ti serve, va aggiunto un controllo nel checkout.

**Codice sperimentale.** In PrestaShop 9.2 il codice delle proprietà aggiuntive è segnato `@experimental`: PrestaShop si tiene la possibilità di un cambio non retrocompatibile, solo se non c'è altra strada. Un modulo piccolo come questo si ricontrolla in pochi minuti a ogni aggiornamento minore.

Un'ultima nota sulla scelta tra back office e codice. Ho lasciato la creazione del campo al back office perché era il caso che volevo mostrare: chi gestisce il negozio lo crea, lo sviluppatore scrive solo il comportamento. Se preferisci che sia il modulo a portarsi dietro il campo, lo registri in `install()` con `registerExtraProperty()`, usando gli stessi valori (entità `combination`, tipo `ExtraPropertyType::BOOL`, `displayFront: true`, `associatedForms: ['combination_form']`). In quel caso, nel codice, al posto di `_core` scrivi `bwcombinazionispente`. La [guida per registrare le proprietà da un modulo](https://devdocs.prestashop-project.org/9/development/components/extra-properties/register-from-module/) ha tutti i parametri.

## Domande frequenti

### PrestaShop permette di disattivare una singola combinazione?

No: il prodotto ha lo stato attivo o non attivo, la combinazione no. Le alternative native sono cancellarla o lasciarla senza giacenza. Con PrestaShop 9.2 aggiungi alla combinazione una proprietà aggiuntiva booleana e un modulo che la legge nel negozio, come in questo articolo.

### Perché il modulo non toglie la combinazione dal selettore delle varianti?

Perché il `ProductController` costruisce l'elenco dei gruppi di attributi senza un hook che permetta di filtrarlo. Il modulo usa solo hook esistenti: rende la variante non acquistabile, mostra un messaggio e blocca l'aggiunta al carrello lato server.

### Serve spuntare "Visualizza in front-office" sulla proprietà?

Sì. Nel negozio il contenitore `extra_properties` contiene solo le proprietà con questa opzione attiva. Senza, il modulo legge sempre un valore vuoto e non spegne niente.

### Le proprietà aggiuntive sono stabili in PrestaShop 9.2?

Il codice è segnato `@experimental`. PrestaShop si riserva un cambio non retrocompatibile solo se non ci sono alternative. Tieni il modulo piccolo e ricontrollalo a ogni aggiornamento minore.

---

Le proprietà aggiuntive di PrestaShop 9.2 tolgono di mezzo tabelle personalizzate e override per molti casi come questo: un interruttore sulle varianti, un codice del gestionale, una nota per il magazzino. Noi di bwlab sviluppiamo moduli PrestaShop e aiutiamo i negozi a passare alla versione 9: trovi come lavoriamo nella pagina [consulenza e sviluppo PrestaShop](/prestashop/consulenza-e-sviluppo-prestashop). Se stai pensando di aggiornare a PrestaShop 9.2 e hai varianti da gestire in modo diverso dallo standard, [scrivici](/contattaci): guardiamo insieme il catalogo e ti diciamo cosa si risolve con un campo dal back office e cosa richiede un modulo.