Synchronisation automatique des prix des lots en cas de modification des prix des variantes

Lorsque vous utilisez l'application « » (Shopify)** « Bundles** » pour créer des lots de produits, la modification du prix d'une variante d'un produit composant n'entraîne pas automatiquement la mise à jour du prix de la variante du lot. Le déclencheur **« Product Variant Price Changed » (**Modification du prix d'une variante de produit) disponible sur Workflow Trigger Extensions résout ce problème en détectant la modification de prix, puis en recalculant et en mettant à jour automatiquement le prix de la variante du lot.

---

Nous allons partir du scénario suivant pour comprendre comment utiliser le déclencheur « Modification du prix d'une variante de produit » afin de synchroniser les prix des offres groupées.

Scénario : mise à jour automatique du prix d'un ensemble lorsqu'une variante de composant change de prix

Imaginez que vous ayez un produit groupé (par exemple, un lot de t-shirts) créé à l'aide de l'application « Bundles » d'Shopify. Ce lot contient trois produits composants : un t-shirt noir, un t-shirt gris et un t-shirt blanc, chacun au prix de 10,00 € par variante. Le prix de la variante du lot est de 30,00 € (somme des prix de tous les produits composants). Lorsque vous modifiez le prix d'une variante d'un produit composant, ce flux mettra automatiquement à jour le prix de la variante du lot correspondante.

Activez ce déclencheur dans les paramètres de l'application -> Variantes de produit -> Modifications des prix des variantes

Modification du prix d'une variante de produit

Récupérez le produit « ensemble » parent, calculez les prix actualisés des variantes et mettez à jour en masse les prix des variantes de l'ensemble via l'API d'administration

Guide vidéo

Vous pouvez également suivre les différentes étapes en images dans cette vidéo (la vidéo est sans son ; vous pouvez régler la vitesse de lecture selon vos besoins)

Comment nous allons organiser cela

Comprendre la configuration

• Nous proposons un produit composé (par exemple, un t-shirt gris) disponible en plusieurs tailles : S, M, L, XL et 2XL, chacune au prix de 10,00 €.
• Nous avons créé un lot de produits à l'aide de l'application « Shopify Bundles ». Il contient 3 produits (un t-shirt noir, un t-shirt gris et un t-shirt blanc), chacun proposant 5 variantes. Le prix de la variante du lot est de 30,00 € (somme des prix des composants : 3 × 10,00 €).

Vous pouvez voir ici, sous forme visuelle, les étapes suivies :

• Dans «Workflow Trigger Extensions », ouvrez « Triggers », recherchez « Price » et activez « Product Variant Price Changed ». Cette action nécessite un accès aux données relatives aux produits, aux variantes et aux collections ; l'application vous le demandera si cet accès fait défaut.
• Créez un nouveau workflow vierge à partir de l’application «Shopify Flow » et sélectionnez le déclencheur « Product Variant Price Changed » de l’application « Workflow Trigger Extensions ».
• Ajoutez une action « Récupérer les données du produit » pour récupérer le produit modifié à l'aide d'une requête avancée, triée par **date de création **(ordre croissant). Cette étape récupère les informations relatives au bundle parent du produit via le champ « productParents ». La requête se présente comme suit : id:{{productVariant.product.id | split: "gid://shopify/Product/" | last}}
• Ajoutez une étape « Exécuter un code » pour extraire l'ID du produit parent du résultat de l'getProductData. Le code extrait les ID des produits parents de productParents et génère une chaîne de caractères idsCondition à utiliser pour la requête.

L'étape « Exécuter le code » utilise l'entrée GraphQL, le code JavaScript et les sorties suivants pour obtenir les identifiants des produits parents :

Étape « Exécuter le code » affichant l'entrée GraphQL, le code JavaScript et l'aperçu de la sortie

{
  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!
}

• Ajoutez une étape « Condition » qui vérifie que la sortie du code « Run » (productId) n'est pas vide et existe bel et bien. Cela permet de s'assurer que nous ne poursuivons la procédure que si le produit modifié fait effectivement partie d'un lot.
• Vrai → continuer à mettre à jour le prix du lot
• Faux → arrêt (le produit ne fait pas partie d'un ensemble)
• Si la condition est vraie, ajoutez une autre action « Récupérer les données du produit (1) » pour récupérer les données relatives aux variantes et aux prix du produit parent à l'aide de l'idsCondition, accessible depuis l'étape « Exécuter le code ».
• Ajoutez une deuxième étape « Exécuter le code (1) » pour calculer les nouveaux prix des variantes de lot en fonction des prix actualisés des composants. Cette étape génère un tableau de type « variantPrices » contenant les nouveaux prix pour chaque variante de lot.

Cette étape « Exécuter le code (1) » consiste à recalculer les prix des variantes de l'offre groupée en fonction du prix actualisé des composants. Voici comment elle fonctionne : tout d'abord, elle extrait deux informations clés du déclencheur :

• changedVariantId la variante qui vient d'être modifiée (...158920)
• newPrice le nouveau prix de cette variante (11.00). Ensuite, le programme passe en revue toutes les variantes de lot et recalcule leur prix total. Chaque variante de lot comprend 3 variantes de composants (T-shirt noir, T-shirt gris, T-shirt blanc). Pour chaque composant, le système vérifie : s'agit-il de la variante qui vient de changer ? Si oui, il utilise newPrice (11,00) au lieu de l'ancien prix encore stocké dans Shopify (10,00). Si non, il utilise l'component.productVariant.price.It existant. Le système additionne les prix des composants pour obtenir le nouveau prix de la variante de lot. Vous pouvez voir le résultat dans vos données de sortie. Considérez la variante ...088840 : ses composants incluent ...158920 (la variante modifiée). Son prix est donc de 11 + 10 + 10 = 31, tandis que toutes les autres variantes de lot totalisent toujours 30, car aucun de leurs composants n’a changé.C’est là l’élément clé de cette étape : Shopify n’a pas encore mis à jour le prix du composant dans les données du pack ; le code ne peut donc pas se contenter d’additionner les prix existants, il doit remplacer à la volée le prix de la variante modifiée par le nouveau prix. Sans cela, toutes les variantes afficheraient toujours 30. Le tableau de sortie variantPricesest ensuite transmis à la boucle « For each », qui appelle productVariantsBulkUpdatepour réécrire effectivement ces prix recalculés dans le produit groupé.

{
  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!]!
}

• Ajoutez une boucle « For each » (itération) qui parcourt chaque élément de la liste « runCode1.variantPrices ». Pour chaque variante de prix, elle exécute l'action « Envoyer une requête API Admin » à l'aide de la mutation « productVariantsBulkUpdate » afin de mettre à jour le prix de la variante du pack. Vous pouvez utiliser cette entrée pour la mutation :

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

Comment tout cela fonctionne ensemble

Lorsqu'un prix de variante d'un produit composant est modifié (par exemple, si vous mettez à jour le prix de la variante « T-shirt gris S » de 10,00 € à 15,00 €) :

1. Le déclencheur « Modification du prix d'une variante de produit » se déclenche
2. Le flux récupère le bundle parent du produit à l'aide de productParents
3. L'étape « Exécuter le code » extrait l'identifiant du produit regroupé
4. Cette condition permet de vérifier si ce produit fait partie d'un lot
5. Si oui, il récupère les données relatives aux produits groupés
6. Une deuxième étape « Exécuter le code » recalcule les prix des variantes de lot
7. La boucle parcourt chaque variante et met à jour le prix du lot via la mutation « productVariantsBulkUpdate » de l’API d’administration.

Le prix de la variante « S » du pack passerait alors de 30,00 € à 35,00 € (15,00 € + 10,00 € + 10,00 €).