Comment travailler avec l’API REST Woocommerce avec Python

Wordpress est probablement le CMS le plus utilisé au monde (on estime que près de 40 % de tous les sites web sont construits à l’aide de la plateforme) : il est très facile à installer et à utiliser, et permet même aux non-développeurs de créer un site web en quelques minutes.
Wordpress dispose d’un très grand écosystème de plugins ; l’un des plus célèbres est Woocommerce, qui nous permet de transformer un site Web en une boutique en ligne en quelques étapes. Le plugin utilise l’infrastructure de l’API REST de Wordpress ; dans ce tutoriel, nous verrons comment interagir avec l’API Woocommerce à l’aide du langage de programmation Python, en montrant comment répertorier, créer, mettre à jour et supprimer des produits et des catégories.

Dans ce tutoriel, vous allez apprendre :

Comment générer des informations d’identification de l’API REST Woocommerce et activer de jolis permaliens
Comment interagir avec l’API REST Woocommerce à l’aide de Python et du package woocommerce
Comment obtenir des informations sur les catégories Woocommerce existantes, les créer, les mettre à jour et les supprimer
Comment obtenir des informations sur les produits Woocommerce existants
Comment créer des produits simples et variables avec des variations
Comment mettre à jour et supprimer un produit

Configuration logicielle requise et conventions utilisées

Génération des informations d’identification de l’API REST Woocommerce

Pour les besoins de ce tutoriel, nous supposerons que nous avons une instance fonctionnelle de Wordpress avec le plugin Woocommerce déjà installé. La première chose que nous devons faire est de générer nos identifiants de l’API REST Woocommerce : ils seront
utilisés dans chaque requête HTTP que nous effectuerons. Pour générer les informations d’identification, c’est très facile ; tout ce que nous avons à faire est de naviguer vers woocommerce -> paramètres dans le menu vertical que nous pouvons trouver dans la page d’administration de Wordpress :

Une fois dans la page des paramètres du plugin, nous cliquons sur l’onglet « Avancé », puis sur
le lien « REST API », qui se trouve sous le menu de l’onglet. Dans la page qui sera
ouverte, on clique sur le bouton « Créer une clé API » :

Le formulaire de création de clé API nous sera présenté et nous serons invités à insérer :

Une description, qui sera utilisée comme un nom convivial pour identifier facilement les informations d’identification
L’utilisateur qui utilisera la clé
Les permissions qui seront accordées à la clé (lecture seule|écriture seule|lecture et écriture)

Notez que nous avons la possibilité de créer plusieurs clés avec des permissions différentes, afin de limiter les opérations accordées pour un utilisateur spécifique. Pour les besoins de ce tutoriel, nous allons créer une clé API avec des autorisations de lecture et d’écriture :

Lorsque nous sommes prêts, nous cliquons sur le bouton « Générer une clé API », et la clé consommateur et la clé secrète consommateur seront générées et nous seront affichées. Nous devons nous assurer de stocker les deux dans un endroit sûr, car une fois que nous quittons la page, ils seront cachés :

Une fois nos clés générées, il y a une autre action que nous devons effectuer depuis le backend d’administration de Wordpress : nous devons nous assurer que le bon joli permalien est utilisé, sinon les points de terminaison de l’API ne fonctionneront pas. Pour accomplir la tâche, nous naviguons vers Paramètres -> permaliens dans le menu vertical gauche de Wordpress. Dans le menu des pages, nous sélectionnons « Nom de l’article », puis nous enregistrons les modifications :

C’est tout ce que nous avons à faire côté Wordpress. Dans la section suivante, nous verrons comment interagir avec les API REST de Woocommerce à l’aide de Python.

Installer le package woocommerce

Dans cette section, nous allons voir comment interagir avec l’API REST de Woocommerce à l’aide du langage de programmation Python. Au lieu d’écrire le code dont nous avons besoin pour effectuer les requêtes HTTP à partir de zéro, nous utiliserons le package woocommerce, ce qui facilitera notre travail. Pour installer le paquet, nous pouvons utiliser pip, le gestionnaire de paquets Python. Si nous travaillons à l’intérieur d’un environnement virtuel créé à l’aide de venv, nous pouvons exécuter :

pip install woocommerce

Si nous n’utilisons pas d’environnement virtuel, nous devrions au moins installer le package pour notre utilisateur uniquement. Pour ce faire, nous ajoutons l’option --user à la commande, qui devient :

pip install woocommerce --user

Une fois le package woocommerce installé, nous pouvons commencer à écrire notre code.

Initialisation de la classe API

La première chose que nous devons faire pour interagir avec l’API REST de Woocommerce, en utilisant Python et le package woocommerce, est d’importer la classe API et de créer une instance de celle-ci, comme indiqué ci-dessous :

#!/usr/bin/env python3
from woocommerce import API

wcapi = API(
  url="http://localhost",
  consumer_key="ck_147eb955838043597462c3f9c4f91cba08498159",
  consumer_secret="cs_55a72d6c7bde09b7f36befed32aa90709261c097",
  timeout=50
)

Le constructeur de la classe API prend trois arguments obligatoires :

L’URL de notre site
La clé consommateur de l’API REST Woocommerce
Le secret consommateur de l’API REST Woocommerce

Dans l’exemple ci-dessus, vous pouvez voir que nous avons passé un troisième argument, timeout : il est facultatif et est par défaut de 5 secondes. Dans ce cas, nous lui donnons une valeur plus grande : 50. Dans mon cas, c’était nécessaire pour que les requêtes aboutissent, mais dans un scénario réel
, nous ne devrions pas avoir besoin de le changer, donc il peut être complètement omis.

Une fois que nous avons créé une instance de la classe API, dans ce cas référencée par la variable wcapi, nous pouvons procéder à nos appels API.

Catégories

Pour les besoins de ce tutoriel, nous ne travaillerons qu’avec des catégories et des produits. Les exemples fournis doivent suffire à donner au lecteur une idée du fonctionnement de l’API. Commençons par les catégories, puisqu’elles doivent préexister afin d’être référencées lors de la création de produits.

Création d’une catégorie

Comme premier exemple, nous allons voir comment créer une catégorie. Nous commençons à définir les données de catégorie dans un dictionnaire Python :

category_data = {
    "name": "Example category",
    "description": "Just a category example"
}

Le seul paramètre obligatoire que nous devons utiliser lors de la création d’une catégorie est name, qui doit être fourni sous forme de chaîne. Dans l’exemple ci-dessus, nous avons également spécifié la clé de description, pour fournir une brève description de la catégorie (vous pouvez consulter la documentation officielle pour la liste complète des propriétés de la catégorie).

Une fois que nous avons créé le dictionnaire contenant les données de la catégorie, nous pouvons exécuter la requête API utilisée pour la création de la catégorie, qui utilise le verbe HTTP POST :

response = wcapi.post("products/categories", category_data)

Si la requête est exécutée sans erreur, l’appel de la méthode json sur l’objet de réponse, renverra la réponse du serveur formatée comme un dictionnaire Python, qui décrit les données utilisées pour créer la catégorie : cela inclura l’ID unique utilisé pour stocker la catégorie dans la base de données, qui est une information essentielle si l’on veut la référencer plus tard (par exemple lors de la création d’une sous-catégorie ou d’un produit qui doit être inclus dans la liste catégorie elle-même). Dans notre cas, voici ce qui est renvoyé par le serveur :

{
  'id': 17,
  'name': 'Example category',
  'slug': 'example-category',
  'parent': 0,
  'description': 'Just a category example',
  'display': 'default',
  'image': None,
  'menu_order': 0,
  'count': 0,
  '_links': {
    'self': [
      {'href': 'http://localhost/wp-json/wc/v3/products/categories/17'}
    ],
    'collection': [
      {'href': 'http://localhost/wp-json/wc/v3/products/categories'}
    ]
  }
}

Comme nous pouvons le voir, la catégorie a été sauvegardée avec 17 comme identifiant unique.

Mettre à jour une catégorie

Pour mettre à jour une catégorie existante, nous devons la référencer via son id, qui doit être inclus dans le point de terminaison de la demande. Tout d’abord, nous créons un dictionnaire qui contient les données de la catégorie qui doivent être mises à jour ; Dans l’exemple ci-dessous, nous modifions la description de la catégorie :

category_data = {
  "description": "Modified category example"
}

Une fois que les données sont prêtes, nous pouvons envoyer notre requête, en utilisant la méthode put de l’objet wcapi, qui, comme vous pouvez le deviner, envoie une requête en utilisant le verbe HTTP PUT :

response = wcapi.put('products/categories/17', category_data)

Comme précédemment, en exécutant la méthode json de l’objet response, nous récupérerons les informations de catégorie mises à jour renvoyées par le serveur, déjà converties en dictionnaire Python :

{
  'id': 17,
  'name': 'Example category',
  'slug': 'example-category',
  'parent': 0,
  'description': 'Modified category example',
  'display': 'default',
  'image': None,
  'menu_order': 0,
  'count': 0,
  '_links': {
    'self': [
      {'href': 'http://localhost/wp-json/wc/v3/products/categories/17'}
    ],
    'collection': [
      {'href': 'http://localhost/wp-json/wc/v3/products/categories'}
    ]
  }
}

Obtenir des informations sur toutes les catégories ou sur une catégorie spécifique

Obtenir une liste de toutes les catégories existantes est vraiment simple. Tout ce que nous avons à faire est d’exécuter la méthode get de l’objet wcapi que nous avons créé précédemment, et de spécifier le bon point de terminaison (produits/catégories) :

response = wcapi.get('products/categories')

Comme précédemment, le contenu de la réponse est accessible sous la forme d’un dictionnaire python en exécutant la méthode json sur l’objet de réponse. Dans ce cas, la méthode renvoie ce qui suit :

[
  {
    'id': 17,
    'name': 'Example category',
    'slug': 'example-category',
    'parent': 0,
    'description': 'Just a category example',
    'display': 'default',
    'image': None,
    'menu_order': 0,
    'count': 0,
    '_links': {
      'self': [
        {'href': 'http://localhost/wp-json/wc/v3/products/categories/17'}
      ],
      'collection': [
        {'href': 'http://localhost/wp-json/wc/v3/products/categories'}
      ]
    }
  },
  {
    'id': 16,
    'name': 'test',
    'slug': 'test',
    'parent': 0,
    'description': 'a test',
    'display': 'default',
    'image': None,
    'menu_order': 0,
    'count': 0,
     '_links': {
       'self': [
         {'href': 'http://localhost/wp-json/wc/v3/products/categories/16'}
        ],
        'collection': [
          {'href': 'http://localhost/wp-json/wc/v3/products/categories'}
        ]
      }
    },
    {
      'id': 15,
      'name': 'Uncategorized',
      'slug': 'uncategorized',
      'parent': 0,
      'description': '',
      'display': 'default',
      'image': None,
      'menu_order': 0,
      'count': 0,
      '_links': {
        'self': [
          {'href': 'http://localhost/wp-json/wc/v3/products/categories/15'}
        ],
        'collection': [
          {'href': 'http://localhost/wp-json/wc/v3/products/categories'}
        ]
      }
    }
  ]

Si nous voulons récupérer des informations sur une catégorie spécifique, il nous suffit de fournir son identifiant dans le cadre du point de terminaison. Par exemple, pour obtenir des détails sur la catégorie avec l’id 16 (test), nous exécuterions :

response = wcapi.get('products/categories/16')

Suppression d’une catégorie

L’id d’une catégorie est également nécessaire pour la référencer lorsque nous voulons la supprimer. Dans ces cas, nous devons exécuter une requête HTTP qui utilise le verbe HTTP DELETE, en fournissant à nouveau l’identifiant de catégorie dans le cadre du point de terminaison. Pour supprimer la catégorie « test », par exemple, il faut exécuter :

response = wcapi.delete('products/categories/16', param={'force', True})

Lors de l’exécution de la méthode delete pour supprimer une catégorie, nous devons également utiliser le paramètre force et le définir sur True. Ceci est nécessaire, car le déplacement d’une catégorie dans la corbeille n’est pas pris en charge via l’API REST ; La ressource sera définitivement supprimée. Si tout se passe comme prévu, comme dans les exemples précédents, l’appel de la méthode json sur l’objet de réponse renverra un dictionnaire contenant les données de ressource supprimées.

Effectuer plusieurs actions à la fois

Supposons que nous voulions effectuer plusieurs actions à la fois : nous pouvons vouloir supprimer certaines catégories, en créer de nouvelles et en mettre à jour d’autres. Comment pouvons-nous le faire en une seule fois, en exécutant une seule requête ? Tout ce que nous avons à faire est d’envoyer une requête en utilisant le verbe HTTP POST au point de terminaison products/categories/batch, en utilisant la méthode post de l’objet wcapi. En voici un exemple :

batch_data = {
  "create": [
    {
      "name": "New category 1",
      "description": "First new category"
    },
    {
      "name": "New category 2",
      "description": "Second new category"
    }
  ],
  "update": [
    {
      "id": 17,
      "description": "updated description"
    }
  ],
  "delete": [
    15
  ]
}

Les données du lot sont définies, comme nous l’avons vu dans les exemples précédents, à l’aide d’un dictionnaire Python. À l’intérieur de ce dictionnaire, nous avons quelques clés nommées d’après les actions qui doivent être effectuées :

créer
mettre à jour
supprimer

La valeur attribuée à la clé de création doit être une liste de dictionnaires, chacun décrivant les données qui doivent être utilisées pour créer une nouvelle catégorie. Dans ce cas, nous avons créé deux nouvelles catégories, nommées « Nouvelle catégorie 1 » et « Nouvelle catégorie 2 ».

De même, la valeur correspondant à la clé de mise à jour doit être une liste de dictionnaires, chacun décrivant les données qui doivent être utilisées pour mettre à jour une certaine catégorie, identifiée par son id.

Enfin, la valeur associée à la clé de suppression doit être une liste de l’id des catégories qui doivent être supprimées. Dans ce cas, nous avons décidé de supprimer la catégorie avec 16 comme identifiant unique. Une fois que nos données sont prêtes, nous exécutons la requête
:

response = wcapi.post('products/categories/batch', batch_data)

L’objet response contiendra la représentation orientée objet de la réponse envoyée par le serveur. Comme toujours, en exécutant la méthode json de cet objet, nous récupérerons le dictionnaire Python contenant un résumé de l’opération effectuée, et la description des catégories impliquées :

{
  'create': [
    {
      'id': 18,
      'name': 'New category 1',
      'slug': 'new-category-1',
      'parent': 0,
      'description': 'First new category',
      'display': 'default',
      'image': None,
      'menu_order': 0,
      'count': 0,
      '_links': {
        'self': [
          {'href': 'http://localhost/wp-json/wc/v3/products/categories/18'}
        ],
       'collection': [
         {'href': 'http://localhost/wp-json/wc/v3/products/categories'}
        ]
      }
    },
    {
      'id': 19,
      'name': 'New category 2',
      'slug': 'new-category-2',
      'parent': 0,
      'description': 'Second new category',
      'display': 'default',
      'image': None,
      'menu_order': 0,
      'count': 0,
      '_links': {
        'self': [
          {'href': 'http://localhost/wp-json/wc/v3/products/categories/19'}
        ],
        'collection': [
          {'href': 'http://localhost/wp-json/wc/v3/products/categories'}
        ]
      }
    }
  ],
  'update': [
    {
      'id': 17,
      'name': 'Example category',
      'slug': 'example-category',
      'parent': 0,
      'description': 'updated description',
      'display': 'default',
      'image': None,
      'menu_order': 0,
      'count': 0,
      '_links': {
        'self': [
          {'href': 'http://localhost/wp-json/wc/v3/products/categories/17'}
        ],
        'collection': [
          {'href': 'http://localhost/wp-json/wc/v3/products/categories'}
        ]
      }
    }
  ],
  'delete': [
    {
      'id': 16,
      'name': 'test',
      'slug': 'test',
      'parent': 0,
      'description': 'a test',
      'display': 'default',
      'image': None,
      'menu_order': 0,
      'count': 0,
      '_links': {
        'self': [
          {'href': 'http://localhost/wp-json/wc/v3/products/categories/16'}
        ],
        'collection': [
          {'href': 'http://localhost/wp-json/wc/v3/products/categories'}
        ]
      }
    }
  ]
}

Produits

Jusqu’à présent, nous avons vu comment effectuer les opérations CRUD de base sur les catégories. Travaillons avec les produits maintenant. Le code qui devrait être utilisé est assez similaire ; ce qui change, bien sûr, ce sont les points de terminaison de l’API et les attributs qui devraient
être utilisés lors de la création d’un produit.

Création d’un produit simple

Le premier exemple que nous allons voir est comment créer un produit « simple », sans variations (les variations sont des versions légèrement différentes d’un même produit, basées par exemple sur des tailles ou des couleurs différentes). Tout d’abord, nous définissons les données product
:

product_data = {
    "name": "Simple example product",
    "type": "simple",
    "regular_price": "22.50",
    "stock_quantity": 10,
    "short_description": "just an example product",
    "description": "This is just an example product, created with the Woocommerce REST API",
    "categories": [
      {
        "id": 17
      }
    ],

    "images": [
        {
            "src": "https://linuxconfig.org/images/linuxconfig_logo.avif",
            "alt": "example-image"
        }
    ]
}

Jetons un coup d’œil aux informations sur le produit que nous avons utilisées dans le dictionnaire product_data. Nous avons défini le nom du produit (exemple de produit simple), puis nous avons spécifié son type, qui dans ce cas est « simple », puisque nous créons l’annonce d’un produit physique sans variations. Ces deux informations doivent être spécifiées sous forme de chaînes.

Nous avons également spécifié le regular_price du produit (chaîne), la quantité en stock (entier), le short_description et la description régulière, tous deux sous forme de chaînes de caractères : ceux-ci sont affichés dans différentes parties de la page lorsque le produit
est visualisé par un client potentiel.

La prochaine chose que nous avons faite a été de spécifier la liste des catégories de produits dans lesquelles le produit devait être inclus. Chaque catégorie doit être référencée par son identifiant (entier). Dans ce cas, nous avons simplement référencé la catégorie avec 17 comme identifiant unique
(« Exemple de catégorie »).

La dernière chose que nous avons définie, c’est la liste des images qui devraient être associées au produit. Chaque image est décrite à l’aide d’un dictionnaire. Ici, nous n’avons utilisé qu’une seule image, en fournissant son src (chaîne) et alt (le texte alternatif, comme
une chaîne).

Celui que nous avons utilisé n’est qu’un très petit sous-ensemble de toutes les propriétés possibles du produit. Une fois nos données prêtes, nous envoyons une requête HTTP POST, en utilisant la méthode post de l’objet wcapi. Le point de terminaison auquel la demande doit être envoyée est
« products » :

response = wcapi.post('products', product_data)

Si la requête aboutit, en exécutant response.json(), nous obtiendrons un dictionnaire Python contenant les informations du produit nouvellement créé :

{
  'id': 29,
  'name': 'Simple example product',
  'slug': 'simple-example-product',
  'permalink': 'http://localhost/product/simple-example-product/',
  'date_created': '2021-03-22T14:53:44',
  'date_created_gmt': '2021-03-22T14:53:44',
  'date_modified': '2021-03-22T14:53:44',
  'date_modified_gmt': '2021-03-22T14:53:44',
  'type': 'simple',
  'status': 'publish',
  'featured': False,
  'catalog_visibility': 'visible',
  'description': 'This is just an example product, created with the Woocommerce REST API',
  'short_description': 'just an example product',
  'sku': '',
  'price': '22.50',
  'regular_price': '22.50',
  'sale_price': '',
  'date_on_sale_from': None,
  'date_on_sale_from_gmt': None,
  'date_on_sale_to': None,
  'date_on_sale_to_gmt': None,
  'on_sale': False,
  'purchasable': True,
  'total_sales': 0,
  'virtual': False,
  'downloadable': False,
  'downloads': [],
  'download_limit': -1,
  'download_expiry': -1,
  'external_url': '',
  'button_text': '',
  'tax_status': 'taxable',
  'tax_class': '',
  'manage_stock': False,
  'stock_quantity': None,
  'backorders': 'no',
  'backorders_allowed': False,
  'backordered': False,
  'sold_individually': False,
  'weight': '',
  'dimensions': {
    'length': '',
    'width': '',
    'height': ''
  },
  'shipping_required': True,
  'shipping_taxable': True,
  'shipping_class': '',
  'shipping_class_id': 0,
  'reviews_allowed': True,
  'average_rating': '0',
  'rating_count': 0,
  'upsell_ids': [],
  'cross_sell_ids': [],
  'parent_id': 0,
  'purchase_note': '',
  'categories': [
    {
      'id': 17,
      'name': 'Example category',
      'slug': 'example-category'
    }
  ],
  'tags': [],
  'images': [
    {
      'id': 28,
      'date_created': '2021-03-22T14:53:44',
      'date_created_gmt': '2021-03-22T14:53:44',
      'date_modified': '2021-03-22T14:53:44',
      'date_modified_gmt': '2021-03-22T14:53:44',
      'src': 'http://localhost/wp-content/uploads/2021/03/linuxconfig_logo-3.png',
      'name': 'linuxconfig_logo-3.png',
      'alt': 'example-image'
    }
  ],
  'attributes': [],
  'default_attributes': [],
  'variations': [],
  'grouped_products': [],
  'menu_order': 0,
  'price_html': '<span class="woocommerce-Price-amount amount"><bdi>22,50<span class="woocommerce-Price-currencySymbol">&euro;</span></bdi></span>',
  'related_ids': [],
  'meta_data': [],
  'stock_status': 'instock',
  '_links': {
    'self': [
      {'href': 'http://localhost/wp-json/wc/v3/products/29'}
    ],
    'collection': [
      {'href': 'http://localhost/wp-json/wc/v3/products'}
    ]
  }
}

Création d’un produit variable et de ses variantes

Dans l’exemple précédent, nous avons créé un produit « simple ». Voyons maintenant comment créer un produit « variable ». La définition de base est la même que celle que nous avons utilisée ci-dessus. Tout ce que nous avons à faire est d’ajouter les attributs qui, combinés, représenteront les variations du produit. Par exemple, supposons que notre produit soit un t-shirt disponible en plusieurs couleurs et tailles : chaque variation sera composée d’une certaine couleur associée à une certaine taille :

variable_product_data = {
  "name": "Variable example product",
  "type": "variable",
  "short_description": "just a variable product",
  "description": "This is a variable product, created with the Woocommerce REST API",
  "categories": [
    {
      "id": 17
    }
  ],
  "images": [
      {
          "src": "https://linuxconfig.org/images/linuxconfig_logo.avif",
          "alt": "example-image"
      }
  ],
  "attributes": [
    {
      "name": "Color",
      "visible": True,
      "variation": True,
      "options": [
        "black",
        "white"
      ]
    },
    {
      "name": "Size",
      "visible": True,
      "variation": True,
      "options": [
        "S",
        "M",
        "L"
      ]
    }
  ]
}

Nous avons fourni une liste d’attributs à l’aide de la clé « attributes " dans le dictionnaire du produit. Le premier attribut s’appelle « Couleur », et le second « Taille ». Nous les avons configurés pour qu’ils soient visibles, et nous avons déclaré qu’ils devaient être utilisés pour les variations en attribuant à True la valeur de la clé de variation dans les dictionnaires qui les définit. La liste associée à la clé d’options contient toutes les valeurs possibles que chaque attribut peut assumer.

À propos des attributs d’un produit : nous pouvons utiliser à la fois des attributs globaux et non globaux. Quelle est la différence ? Les attributs spécifiés uniquement par leur nom comme nous l’avons fait dans l’exemple ci-dessus seront créés « à la volée » pour le produit spécifique, ils seront donc « non globaux ». Si nous voulions utiliser le même attribut pour plusieurs produits, il est préférable de le définir au préalable avec un appel spécifique, puis de le référencer par leur id. Supposons que nous créions les attributs globaux Color et Size, et qu’ils aient respectivement 1 et 2 comme identifiants uniques, nous écririons :

"attributes": [
    {
      "id": 1
      "visible": True,
      "variation": True,
      "options": [
        "black",
        "white"
      ]
    },
    {
      "id": 2,
      "visible": True,
      "variation": True,
      "options": [
        "S",
        "M",
        "L"
      ]
    }
]

Très important : le code ne créera pas les variantes de produit réelles, qui doivent être définies avec des demandes distinctes.

Vous pouvez remarquer que nous avons omis de fournir la quantité de stock du produit, car la valeur totale du stock sera représentée par la somme de la quantité de stock de chaque variante.

L’étape suivante consiste à créer les variantes de produit réelles. Lors de la définition des données de variations, nous devons utiliser les mêmes attributs que ceux que nous avons définis dans la demande que nous avons utilisée pour créer la variable produit. Voici un exemple de création d’une variante :

product_variation_data = {
    "regular_price": "18.00",
    "stock_quantity": 10,
    "attributes": [
        {
          "id": 1,
          "option": "white"
        },
        {
          "id": 2,
          "option": "S"
        }
    ]
}

Nous avons défini la variation produite par la combinaison de l’attribut Couleur « blanc » et de l’attribut Taille « S ». Nous fixons ses regular_price et ses stock_quantity. Nous devons maintenant envoyer la demande avec le code suivant :

response = wcapi.post('products/34/variations', product_variation_data)

Comme vous pouvez le voir dans l’extrait ci-dessus, comme point de terminaison de la demande, nous avons utilisé products/34/variations, où 34 est l’ID du produit parent que nous avons précédemment créé.

Demande d’informations sur tous les produits ou sur un produit spécifique

Tout comme nous l’avons fait pour les catégories, nous pouvons demander des informations sur tous les produits existants via l’API REST de Woocommerce :

response = wcapi.get('products')

La requête pourrait être davantage personnalisée par l’utilisation de paramètres : avec le paramètre per_page, par exemple, nous pouvons spécifier combien d’éléments doivent être renvoyés dans le jeu de résultats d’une seule requête (la valeur par défaut est 10), et avec le paramètre page, nous pouvons demander la page spécifique qui doit être renvoyée (la valeur par défaut est 1). Pour étendre le nombre d’éléments renvoyés dans une seule requête, nous écririons :

response = wcapi.get('products', params={'per_page': 20})

Pour demander des informations sur un produit spécifique, c’est tout aussi simple : il suffit de spécifier son id dans le point de terminaison de la requête :

response = wcapi.get('products/34')

Mise à jour d’un produit

La logique utilisée pour mettre à jour un produit est la même que celle utilisée pour mettre à jour une catégorie (et toutes les autres « entités » gérées via l’API REST). Nous spécifions les données produit qui doivent être mises à jour et envoyons une requête PUT au point de terminaison qui inclut l’ID du produit :

updated_product_data = {
  "description": "This is the updated variable product description"
}

response = wcapi.put('products/34', updated_product_data)

Supprimer un produit

Pour supprimer un produit, il suffit d’envoyer une requête DELETE au point de terminaison qui inclut l’identifiant du produit :

response = wcapi.delete('products/34')

Ici, vous pouvez remarquer que, contrairement à ce qui se passe pour les catégories, l’utilisation du paramètre force n’est pas obligatoire. Si le paramètre n’est pas utilisé, le produit sera simplement déplacé dans la « Corbeille », et il sera donc possible de le récupérer à partir de celui-ci ultérieurement. Si le paramètre force est utilisé et défini sur True, le produit sera définitivement supprimé.

Conclusions

Dans ce tutoriel, nous avons vu quelques exemples de comment interagir avec l’API REST de Woocommerce avec le langage de programmation Python. Nous avons vu comment générer des identifiants API, comment installer le package Python « woocommerce » qui fournit des méthodes utiles qui simplifient le code que nous devrions écrire pour interagir avec eux, et quelques exemples de comment créer, lire, supprimer et mettre à jour les catégories et les produits Woocommerce. Veuillez consulter la documentation officielle de l’API REST de Woocommerce pour un aperçu complet des capacités de l’API.