Compatibilidad con Content API para Shopping

Puedes usar esta guía para integrar la API de Merchant con tu implementación existente de Content API for Shopping.

La API de Merchant te permite automatizar los flujos de trabajo de administración relacionados con las cuentas, los productos y el inventario en Merchant Center. Estos son algunos casos de uso de la API de Merchant Center:

• Administración automática de cuentas
• Administración de productos automatizada
• Administración automatizada del inventario
• Informes personalizados

Mejoras con respecto a Content API

La API de Merchant mejora en las siguientes áreas en comparación con Content API:

• Sub-APIs con funciones nuevas para tu integración única
• Nuevos métodos para el inventario, los datos de productos y otras APIs
• La capacidad de crear no solo fuentes de datos principales, sino varias fuentes de datos, como las siguientes:
  • Fuentes de datos de productos complementarias
  • Fuentes de datos del inventario local
  • Fuentes de datos de inventario regionales
  • Fuentes de datos de promociones
  • Fuentes de datos de opiniones sobre productos
  • Fuentes de datos de opiniones sobre comercios
• Se introduce la carga de opiniones sobre productos y opiniones sobre comercios
• Con la API de Merchant Center, puedes habilitar notificaciones para los cambios en los datos de la cuenta.

Comenzar

Consulta el diseño de la API de Merchant para obtener detalles sobre la API de Merchant y sus sub-APIs.

Para comenzar a usar la API de Merchant, cambia las URLs de tus solicitudes al siguiente formato:

https://merchantapi.googleapis.com/{SUB_API}/{VERSION}/{RESOURCE_NAME}:{METHOD}…

Para obtener más información, consulta la guía de inicio rápido y la referencia de la API de Merchant.

Compatibilidad con gRPC

La API de Merchant admite gRPC y REST. Puedes usar gRPC para la API de Merchant y REST para Content API for Shopping al mismo tiempo.

Las bibliotecas cliente de la API de Merchant requieren gRPC.

Consulta Cómo usar gRPC para obtener más información.

Compatibilidad

En esta guía, se describen los cambios generales que se aplican a toda la API de Merchant. Consulta las siguientes guías para conocer los cambios en funciones específicas:

• Administración de la migración de cuentas
• Cómo migrar la configuración de envío
• Cómo migrar la administración de productos
• Cómo migrar la administración de fuentes de datos
• Cómo migrar la administración de inventarios
• Cómo migrar la administración de promociones
• Cómo migrar la administración de informes
• Cómo migrar la administración de las fuentes de conversiones
• Cómo migrar la administración de asociaciones de feeds locales

La API de Merchant está diseñada para funcionar junto con las funciones existentes de Content API for Shopping v2.1.

Por ejemplo, puedes usar la API de Merchant Inventories junto con tu implementación existente de products de Content API for Shopping v2.1. Puedes usar Content API for Shopping para subir un nuevo producto local (que vendes en una tienda local) y, luego, usar el recurso de la API de Merchant Inventories LocalInventory para administrar la información en la tienda de ese producto.

Nota: No podemos garantizar la retrocompatibilidad completa para funciones similares entre Content API for Shopping y la API de Merchant debido al diseño mejorado. Por ejemplo, los nombres de los campos o la disponibilidad de los métodos pueden diferir para el mismo recurso en Content API for Shopping y Merchant API.

Utiliza solicitudes por lotes

La API de Merchant no admite el método customBatch que se incluye en Content API for Shopping. En su lugar, consulta Cómo enviar varias solicitudes a la vez o ejecuta tus llamadas de forma asíncrona.

En el siguiente ejemplo, se muestra cómo insertar una entrada de producto.

Java

import com.google.api.core.ApiFuture;
import com.google.api.core.ApiFutureCallback;
import com.google.api.core.ApiFutures;
import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.shopping.merchant.products.v1beta.Attributes;
import com.google.shopping.merchant.products.v1beta.InsertProductInputRequest;
import com.google.shopping.merchant.products.v1beta.ProductInput;
import com.google.shopping.merchant.products.v1beta.ProductInputsServiceClient;
import com.google.shopping.merchant.products.v1beta.ProductInputsServiceSettings;
import com.google.shopping.merchant.products.v1beta.Shipping;
import com.google.shopping.type.Channel.ChannelEnum;
import com.google.shopping.type.Price;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to insert a product input */
public class InsertProductInputAsyncSample {

  private static String getParent(String accountId) {
    return String.format("accounts/%s", accountId);
  }

  private static String generateRandomString() {
    String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    Random random = new Random();
    StringBuilder sb = new StringBuilder(8);
    for (int i = 0; i < 8; i++) {
      sb.append(characters.charAt(random.nextInt(characters.length())));
    }
    return sb.toString();
  }

  private static ProductInput createRandomProduct() {
    Price price = Price.newBuilder().setAmountMicros(33_450_000).setCurrencyCode("USD").build();

    Shipping shipping =
        Shipping.newBuilder().setPrice(price).setCountry("GB").setService("1st class post").build();

    Shipping shipping2 =
        Shipping.newBuilder().setPrice(price).setCountry("FR").setService("1st class post").build();

    Attributes attributes =
        Attributes.newBuilder()
            .setTitle("A Tale of Two Cities")
            .setDescription("A classic novel about the French Revolution")
            .setLink("https://exampleWebsite.com/tale-of-two-cities.html")
            .setImageLink("https://exampleWebsite.com/tale-of-two-cities.jpg")
            .setAvailability("in stock")
            .setCondition("new")
            .setGoogleProductCategory("Media > Books")
            .setGtin(0, "9780007350896")
            .addShipping(shipping)
            .addShipping(shipping2)
            .build();

    return ProductInput.newBuilder()
        .setChannel(ChannelEnum.ONLINE)
        .setContentLanguage("en")
        .setFeedLabel("CH")
        .setOfferId(generateRandomString())
        .setAttributes(attributes)
        .build();
  }

  public static void asyncInsertProductInput(Config config, String dataSource) throws Exception {

    // Obtains OAuth token based on the user's configuration.
    GoogleCredentials credential = new Authenticator().authenticate();

    // Creates service settings using the credentials retrieved above.
    ProductInputsServiceSettings productInputsServiceSettings =
        ProductInputsServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Creates parent to identify where to insert the product.
    String parent = getParent(config.getAccountId().toString());

    // Calls the API and catches and prints any network failures/errors.
    try (ProductInputsServiceClient productInputsServiceClient =
        ProductInputsServiceClient.create(productInputsServiceSettings)) {

      // Creates five insert product input requests with random product IDs.
      List<InsertProductInputRequest> requests = new ArrayList<>(5);
      for (int i = 0; i < 5; i++) {
        InsertProductInputRequest request =
            InsertProductInputRequest.newBuilder()
                .setParent(parent)
                // You can only insert products into datasource types of Input "API" and "FILE", and
                // of Type "Primary" or "Supplemental."
                // This field takes the `name` field of the datasource.
                .setDataSource(dataSource)
                // If this product is already owned by another datasource, when re-inserting, the
                // new datasource will take ownership of the product.
                .setProductInput(createRandomProduct())
                .build();

        requests.add(request);
      }

      System.out.println("Sending insert product input requests");
      List<ApiFuture<ProductInput>> futures =
          requests.stream()
              .map(
                  request ->
                      productInputsServiceClient.insertProductInputCallable().futureCall(request))
              .collect(Collectors.toList());

      // Creates callback to handle the responses when all are ready.
      ApiFuture<List<ProductInput>> responses = ApiFutures.allAsList(futures);
      ApiFutures.addCallback(
          responses,
          new ApiFutureCallback<List<ProductInput>>() {
            @Override
            public void onSuccess(List<ProductInput> results) {
              System.out.println("Inserted products below");
              System.out.println(results);
            }

            @Override
            public void onFailure(Throwable throwable) {
              System.out.println(throwable);
            }
          },
          MoreExecutors.directExecutor());

    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    // Identifies the data source that will own the product input.
    String dataSource = "accounts/" + config.getAccountId() + "/dataSources/{datasourceId}";

    asyncInsertProductInput(config, dataSource);
  }
}
InsertProductInputAsyncSample.java

Si usas customBatch en Content API y necesitas esta función para la API de Merchant Center, cuéntanos por qué en tus comentarios.

Identificadores

Para alinearnos con los principios de mejora de las APIs de Google, realizamos algunos cambios en los identificadores de los recursos de la API de Merchant Center.

El nombre reemplaza al ID

Todos los recursos de la API de Merchant usan el campo name como identificador único.

Este es un ejemplo de cómo usar el campo name en tus llamadas:

POST https://merchantapi.googleapis.com/inventories/v1beta/{PARENT}/regionalInventories:insert

Este nuevo campo name se muestra como el identificador de recursos para todas las llamadas de lectura y escritura en la API de Merchant.

Importante: Te recomendamos que uses el valor del campo name directamente en tus llamadas, en lugar de analizar o construir manualmente el nombre de un recurso para evitar problemas.

Por ejemplo, implementa un método getName() para recuperar el name de un recurso y almacenar el resultado como una variable en lugar de construir el name a partir de los IDs del comercio y del recurso por tu cuenta.

campos superiores para recursos secundarios

En la API de Merchant, todos los recursos secundarios tienen el campo parent. Puedes usar el campo parent para especificar el name del recurso en el que se insertará el secundario, en lugar de pasar todo el recurso superior. También puedes usar el campo parent con los métodos list para enumerar los recursos secundarios de ese parent.

Por ejemplo, para enumerar los inventarios locales de un producto determinado, especifica el name del producto en el campo parent del método list. En este caso, el product determinado es el parent de los recursos LocalInventory que se muestran.

Tipos

Estos son algunos tipos comunes que se comparten entre las sub-APIs de la API de Merchant Center.

Precio

Estos son los cambios para Price en el paquete Merchant Common:

	Content API	API de Merchant
Campo de importe	value:string	amountMicros:int64
Campo de moneda	currency:string	currencyCode:string

El importe de Price ahora se registra en micros, en el que 1 millón de micros equivale a la unidad estándar de tu moneda.

En Content API for Shopping, Price era un número decimal en forma de cadena.

El nombre del campo de importe cambió de value a amountMicros

El nombre del campo de moneda cambió de currency a currencyCode. El formato sigue siendo ISO 4217.