Sincronizzazione automatica dei prezzi dei pacchetti in caso di variazioni dei prezzi delle varianti

Quando si utilizza l'app Shopify Bundles per creare pacchetti di prodotti, la modifica del prezzo di una variante di un prodotto componente non aggiorna automaticamente il prezzo della variante del pacchetto. Il trigger "Product Variant Price Changed" disponibile su Workflow Trigger Extensions risolve questo problema rilevando la variazione di prezzo e ricalcolando e aggiornando automaticamente il prezzo della variante del pacchetto.

---

Ipermetteremo il seguente scenario per capire come utilizzare il trigger “Modifica del prezzo della variante di prodotto” per mantenere sincronizzati i prezzi dei pacchetti.

Scenario: aggiornamento automatico del prezzo del pacchetto quando cambia il prezzo di una variante di un componente

Immagina di avere un prodotto in bundle (ad esempio, un bundle di magliette) creato con l'app "Shopify: Bundles". Il bundle contiene tre prodotti componenti: maglietta nera, maglietta grigia e maglietta bianca, ciascuno al prezzo di 10,00 € per variante. Il prezzo della variante del pacchetto è di 30,00 € (la somma dei prezzi di tutti i prodotti che lo compongono). Quando modifichi il prezzo di una variante di un prodotto che compone il pacchetto, questo flusso aggiornerà automaticamente il prezzo della variante corrispondente del pacchetto.

Attiva questo trigger dalle impostazioni dell'app -> Varianti del prodotto -> Modifiche ai prezzi delle varianti

Modifica del prezzo di una variante del prodotto

Recupera il prodotto principale del pacchetto, calcola i prezzi aggiornati delle varianti e aggiorna in blocco i prezzi delle varianti del pacchetto tramite l'API di amministrazione

Guida video

Puoi vedere i passaggi anche in questo video (il video è muto, puoi regolare la velocità in base alle tue esigenze)

Come faremo in modo che tutto proceda senza intoppi

Comprendere la configurazione

• Abbiamo un prodotto composto (ad esempio, una maglietta grigia) con le varianti S, M, L, XL, 2XL, ciascuna al prezzo di 10,00 €.
• Abbiamo creato un prodotto in bundle utilizzando l'app "Shopify Bundles". Contiene 3 prodotti in bundle (maglietta nera, maglietta grigia, maglietta bianca), ciascuno con 5 varianti. Il prezzo della variante del bundle è di 30,00 € (somma dei prezzi dei componenti: 3 × 10,00 €).

Qui puoi vedere visivamente i passaggi seguiti:

• In "Workflow Trigger Extensions", apri "Trigger", cerca "Prezzo" e attiva "Modifica del prezzo della variante del prodotto". È necessario l'accesso ai dati relativi a prodotto, variante e collezione; l'app lo richiederà se non è presente.
• Crea un nuovo flusso di lavoro vuoto dall'app Shopify Flow e seleziona il trigger "Product Variant Price Changed" dall'app "Workflow Trigger Extensions"
• Aggiungi un'azione "Recupera dati prodotto" per recuperare il prodotto modificato utilizzando una query avanzata, ordinata in ordine crescente in base al campo "Creato il". Questo passaggio recupera le informazioni sul bundle padre del prodotto tramite il campo productParents. La query è la seguente: id:{{productVariant.product.id | split: "gid://shopify/Product/" | last}}
• Aggiungi un passaggio "Esegui codice" per estrarre l'ID del prodotto principale dal risultato di getProductData. Il codice estrae gli ID dei prodotti principali da productParents e genera una stringa idsCondition da utilizzare per l'interrogazione.

Il passaggio "Esegui codice" utilizza il seguente input GraphQL, il codice JavaScript e i risultati in uscita per ottenere gli ID dei prodotti principali:

Esegui il passaggio "Codice" che mostra l'input GraphQL, il codice JavaScript e l'anteprima dell'output

{
  getProductData {
    productParents {
      id
    }
  }
}

export default function main(input) {
  const productIds = input.getProductData[0]?.productParents?.map(p => p.id) ?? [];
  const productId = productIds[0] ?? null;

  const idsCondition = productIds
    .map(gid => "id:" + gid.split("gid://shopify/Product/").pop())
    .join(" OR ");

  return {
    productId: productId,
    productIds: productIds,
    idsCondition: idsCondition,
  };
}

type Output {
  productId: String
  productIds: [String!]!
  idsCondition: String!
}

• Aggiungi un passo "Condizione" che verifichi che l'output del codice "Esegui" productId non sia vuoto ed esista effettivamente. In questo modo ci assicuriamo di procedere solo quando il prodotto modificato fa effettivamente parte di un pacchetto.
• Vero → continuare ad aggiornare il prezzo del pacchetto
• Falso → stop (il prodotto non fa parte di un pacchetto)
• Se la condizione è vera, aggiungi un'altra azione "Recupera dati prodotto (1)" per recuperare i dati relativi alle varianti e ai prezzi del prodotto principale del bundle utilizzando l'idsConditione dal passaggio "Esegui codice".
• Aggiungere un secondo passaggio "Esegui codice (1)" per calcolare i nuovi prezzi delle varianti dei pacchetti in base ai prezzi aggiornati dei componenti. Questo passaggio genera un array variantPrices contenente i nuovi prezzi per ciascuna variante di pacchetto.

Questa fase "Esegui codice (1)" ricalcola i prezzi delle varianti del pacchetto in base al prezzo aggiornato dei componenti. Ecco come funziona: innanzitutto, estrae due informazioni chiave dal trigger:

• changedVariantId la variante appena modificata (...158920)
• newPrice il nuovo prezzo di quella variante (11.00). Quindi esegue un ciclo su ogni variante del pacchetto e ricalcola il suo prezzo totale. Ogni variante del pacchetto comprende 3 varianti di componenti (maglietta nera, maglietta grigia, maglietta bianca). Per ogni componente, verifica: si tratta della variante che è appena cambiata? Se sì, utilizza newPrice (11,00) invece del prezzo obsoleto ancora memorizzato in Shopify (10,00). Se no, utilizza il prezzo esistente component.productVariant.price.It. Sommando i prezzi dei componenti si ottiene il nuovo prezzo della variante del pacchetto. Puoi vedere come funziona nei tuoi dati di output. Osservate la variante ...088840: i suoi componenti includono ...158920 (la variante modificata). Pertanto, il suo prezzo è 11 + 10 + 10 = 31, mentre tutte le altre varianti del pacchetto mantengono un totale di 30 poiché nessuno dei loro componenti è cambiato.Questo è il concetto chiave di questo passaggio: Shopify non ha ancora aggiornato il prezzo del componente nei dati del pacchetto, quindi il codice non può limitarsi a sommare i prezzi esistenti, ma deve sostituire al volo il prezzo della variante modificata con quello nuovo. Senza questa operazione, tutte le varianti continuerebbero a mostrare il valore 30. L’array di output variantPricesviene quindi passato al ciclo «For each», che chiama productVariantsBulkUpdateper riscrivere effettivamente questi prezzi ricalcolati nel prodotto in bundle.

{
  productVariant {
    id
  }
  priceChange {
    oldPrice { amount }
    newPrice { amount }
  }
  getProductData1 {
    id
    variants {
      id
      productVariantComponents {
        productVariant {
          id
          price
        }
      }
    }
  }
}

export default function main(input) {
  const changedVariantId = input.productVariant.id;
  const newPrice = parseFloat(input.priceChange.newPrice.amount);

  const variantPrices = input.getProductData1.flatMap(product =>
    product.variants.map(variant => ({
      productId: product.id,
      id: variant.id,
      price: variant.productVariantComponents.reduce((sum, component) => {
        const p = component.productVariant.id === changedVariantId
          ? newPrice
          : parseFloat(component.productVariant.price);
        return sum + p;
      }, 0)
    }))
  );

  return { variantPrices };
}

type VariantPrice {
  productId: String!
  id: String!
  price: Float!
}
type Output {
  variantPrices: [VariantPrice!]!
}

• Aggiungi un ciclo "For each" (iterazione) che scorra tutti gli elementi presenti nel campo runCode1.variantPrices. Per ogni prezzo di variante, esegue l'azione "Invia richiesta API Amministrazione" utilizzando la mutazione "productVariantsBulkUpdate" per aggiornare il prezzo della variante del pacchetto. È possibile utilizzare questo input per la mutazione:

{
  "variants": [
    {
      "id": "{{variantPricesForeachitem.id}}",
      "price": "{{variantPricesForeachitem.price}}"
    }
  ],
  "productId": "{{variantPricesForeachitem.productId}}",
  "allowPartialUpdates": true
}

Come funziona il tutto nel suo insieme

Quando il prezzo di una variante di un prodotto (ad esempio, se si aggiorna il prezzo della variante "S" della maglietta grigia da 10,00 € a 15,00 €):

1. Si attiva il trigger “Modifica del prezzo della variante del prodotto”
2. Il flusso recupera il bundle padre del prodotto utilizzando productParents
3. Il passaggio "Esegui codice" estrae l'ID del prodotto in bundle
4. Questa condizione verifica se il prodotto fa parte di un pacchetto
5. In caso affermativo, recupera i dati relativi al pacchetto di prodotti
6. Una seconda fase di esecuzione del codice ricalcola i prezzi delle varianti del pacchetto
7. Il ciclo esegue un'iterazione su ciascuna variante e aggiorna il prezzo del pacchetto tramite la mutazione dell'API di amministrazione productVariantsBulkUpdate

Il prezzo della variante "Bundle S" verrebbe ora aggiornato da 30,00 € a 35,00 € (15,00 € + 10,00 € + 10,00 €).