Administra las relaciones de la cuenta

Puedes usar la API de Accounts para administrar las relaciones entre tu cuenta de Merchant Center y otros proveedores de servicios. Una relación es una conexión formal que permite que un proveedor ofrezca servicios específicos a tu empresa. Un servicio define los permisos y las capacidades que se otorgan al proveedor, como la administración de productos o de campañas. Por ejemplo, si vinculas tu cuenta de Merchant Center a una cuenta de Google Ads, la cuenta de Ads podrá usar tus datos de productos para publicar campañas publicitarias.

Una relación se compone de los siguientes atributos:

  • La cuenta de Merchant Center que recibe el servicio
  • El proveedor de servicios
  • El servicio o el conjunto de servicios que se proporcionan a la cuenta de Merchant Center

Alias

Los proveedores de servicios pueden asociar un alias con las cuentas que atienden (esto es el equivalente del campo seller_id que estaba presente en el recurso de cuenta en Content API for Shopping). El alias se puede asignar con el campo opcional account_id_alias dentro del recurso AccountRelationship y sirve como identificador personalizado. El alias debe constar de 1 a 50 caracteres elegidos entre letras ASCII, dígitos decimales, guiones, guiones bajos, puntos o tildes ([A-Za-z0-9_~.-]{1,50}).

La estructura de la URL para acceder a una cuenta con su alias es GET /accounts/v1/accounts/{provider}~{account_id_alias}.

Servicios

En la API de Accounts, las cuentas pueden recibir los siguientes servicios. Puedes agregar muchos de estos servicios durante la creación de la cuenta.

  • Agregación de cuentas: Este servicio vincula una cuenta avanzada a otra cuenta, lo que le otorga a la cuenta avanzada acceso completo y sin restricciones. Por lo general, lo usan los mercados, los comercios minoristas de varias marcas o los comercios minoristas internacionales que necesitan un control centralizado sobre las cuentas anidadas. Si eres una plataforma de comercio electrónico o un socio de canal, te recomendamos que uses accountManagement en su lugar. Cuando creas una cuenta con la agregación de cuentas, se debe omitir externalAccountId.

  • Administración de campañas: Este servicio modela el vínculo entre una cuenta de Merchant Center y una cuenta de Google Ads, lo que le da a la cuenta de Ads acceso a los datos de productos y de la cuenta necesarios para publicar campañas publicitarias. En este caso, el proveedor de servicios es GOOGLE_ADS y el externalAccountId es el ID de la cuenta de Google Ads. Este servicio también se puede proponer a una cuenta existente.

  • Comparación de productos: Representa la relación con un servicio de comparación de productos (CSS) que opera la cuenta de Merchant Center.

  • Administración de fichas locales: Representa la relación con un administrador de tienda para administrar el inventario y las fichas locales con un Perfil de Negocio de Google.

  • Administración de cuentas: Este servicio permite que el proveedor realice acciones administrativas en la cuenta de Merchant Center, como configurar parámetros de configuración de la cuenta, administrar usuarios o actualizar la información de la empresa. La empresa también puede restringir el acceso otorgado. Cuando se usa durante la creación de la cuenta, este servicio crea una cuenta vinculada al proveedor, que es el enfoque recomendado para las plataformas de comercio electrónico y los socios de canal. También se puede proponer a una cuenta existente.

  • Administración de productos: Este servicio permite que los proveedores administren productos y funciones relacionadas, como fuentes de datos y reglas. Cuando se agrega durante la creación de la cuenta, suele combinarse con accountManagement o accountAggregation. Este servicio también se puede proponer a una cuenta existente.

Apretón de manos

Para establecer un servicio, tanto la cuenta que proporciona el servicio como la que lo recibe deben autorizar la conexión. Este proceso de autorización se denomina apretón de manos.

El apretón de manos es un proceso de dos pasos:

  1. Una de las partes propone un vínculo de servicio.
  2. La otra parte aprueba o rechaza la propuesta.

Una vez que se acepta una propuesta, el servicio se aprueba y se considera completamente establecido. Cualquier derecho de acceso conferido al proveedor de servicios ahora se otorga a los usuarios calificados (consulta los derechos de acceso a continuación).

Ten en cuenta que el usuario que crea una propuesta, la rechaza o la aprueba debe tener ADMIN derechos de acceso en la cuenta que inicia el proceso. Por lo tanto, si el proveedor de servicios propone un servicio, el usuario que realiza la propuesta debe ser un ADMIN en la cuenta del proveedor de servicios, y el usuario que acepta o rechaza la propuesta debe ser un ADMIN en la cuenta receptora.

En los siguientes ejemplos, se muestra cómo proponer un servicio de cuenta:

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.AccountName;
import com.google.shopping.merchant.accounts.v1.AccountService;
import com.google.shopping.merchant.accounts.v1.AccountServicesServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountServicesServiceSettings;
import com.google.shopping.merchant.accounts.v1.ProductsManagement;
import com.google.shopping.merchant.accounts.v1.ProposeAccountServiceRequest;
import shopping.merchant.samples.utils.Authenticator;

/** This class demonstrates how to propose a service to an existing Merchant Center account. */
public class ProposeServiceSample {

  public static void proposeService(long accountId, long providerId, String externalAccountId)
      throws Exception {

    // Obtains OAuth token based on the user's configuration.
    // The user that authenticates should have access to the account.
    GoogleCredentials credential = new Authenticator().authenticate();

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

    // Calls the API and catches and prints any network failures/errors.
    try (AccountServicesServiceClient accountServicesServiceClient =
        AccountServicesServiceClient.create(accountServicesServiceSettings)) {

      // The service to be proposed.
      // This sample shows how to propose product management.
      // For more information about the different services, see:
      // https://developers.google.com/merchant/api/guides/accounts/services
      AccountService accountService =
          AccountService.newBuilder()
              .setProductsManagement(ProductsManagement.newBuilder().build())
              .setExternalAccountId(externalAccountId)
              .build();

      String accountName =
          AccountName.newBuilder().setAccount(String.valueOf(accountId)).build().toString();

      ProposeAccountServiceRequest request =
          ProposeAccountServiceRequest.newBuilder()
              .setParent(accountName)
              .setProvider("accounts/" + providerId)
              .setAccountService(accountService)
              .build();

      System.out.println("Sending Propose Service request:");
      AccountService response = accountServicesServiceClient.proposeAccountService(request);

      System.out.println("Proposed Service below");
      System.out.println(response);
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    // The ID of the account to propose the service to.
    long accountId = 123L;
    // This is the provider ID of the e-commerce platform.
    long providerId = 456L;
    // An external ID that uniquely identifies the account service.
    String externalAccountId = "ext-acc-id-123";
    proposeService(accountId, providerId, externalAccountId);
  }
}

PHP

require_once __DIR__ . '/../../../../vendor/autoload.php';
require_once __DIR__ . '/../../../Authentication/Authentication.php';
require_once __DIR__ . '/../../../Authentication/Config.php';

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\AccountAggregation;
use Google\Shopping\Merchant\Accounts\V1\AccountService;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountServicesServiceClient;
use Google\Shopping\Merchant\Accounts\V1\ProposeAccountServiceRequest;

/**
 * This class demonstrates how to propose an account service.
 */
class ProposeAccountServiceSample
{
    /**
     * A helper function to create the account name string.
     *
     * @param string $accountId The ID of the account.
     *
     * @return string The account name has the format: `accounts/{account_id}`
     */
    private static function toAccountName(string $accountId): string
    {
        return sprintf('accounts/%s', $accountId);
    }

    /**
     * Proposes a new account service.
     *
     * @param array $config The configuration data used for authentication and
     *     getting the account ID.
     * @param string $providerId The ID of the provider account.
     */
    public static function proposeAccountService(
        array $config,
        string $providerId
    ): void {
        // Gets the OAuth credentials to make the request.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Creates options containing credentials for the client to use.
        $options = ['credentials' => $credentials];

        // Creates a client.
        $accountServicesServiceClient = new AccountServicesServiceClient($options);

        // Calls the API and catches and prints any network failures/errors.
        try {
            $accountAggregation = new AccountAggregation();
            $accountService = (new AccountService())
                ->setAccountAggregation($accountAggregation);

            $request = (new ProposeAccountServiceRequest())
                ->setParent(self::toAccountName($config['accountId']))
                ->setProvider(self::toAccountName($providerId))
                ->setAccountService($accountService);

            print "Sending Propose AccountService request\n";
            $response = $accountServicesServiceClient->proposeAccountService($request);
            print "Proposed AccountService below\n";
            print $response->serializeToJsonString(true) . PHP_EOL;
        } catch (ApiException $e) {
            printf("An error has occurred: %s%s", $e->getMessage(), PHP_EOL);
        }
    }

    /**
     * Helper to execute the sample.
     */
    public function callSample(): void
    {
        $config = Config::generateConfig();

        // Update this with the Merchant Center provider ID you want to get the
        // relationship for.
        $providerId = 111;
        self::proposeAccountService($config, $providerId);
    }
}

// Run the script
$sample = new ProposeAccountServiceSample();
$sample->callSample();

Python

"""This class demonstrates how to propose an account service."""

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AccountAggregation
from google.shopping.merchant_accounts_v1 import AccountService
from google.shopping.merchant_accounts_v1 import AccountServicesServiceClient
from google.shopping.merchant_accounts_v1 import ProposeAccountServiceRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()
_PARENT = f"accounts/{_ACCOUNT}"


def propose_account_service(provider_id: int) -> None:
  """Proposes an account service.

  Args:
    provider_id: The Merchant Center ID of the provider.
  """
  # Gets OAuth Credentials.
  credentials = generate_user_credentials.main()

  # Creates a client.
  client = AccountServicesServiceClient(credentials=credentials)

  # Creates the provider resource name from the provider ID.
  provider = f"accounts/{provider_id}"

  # Creates an AccountService object.
  # For this request, only `account_aggregation` is needed.
  account_service = AccountService()
  account_service.account_aggregation = AccountAggregation()

  # Creates the request.
  request = ProposeAccountServiceRequest(
      parent=_PARENT,
      provider=provider,
      account_service=account_service,
  )

  # Makes the request and catches and prints any error messages.
  try:
    print("Sending Propose AccountService request")
    response = client.propose_account_service(request=request)
    print("Proposed AccountService below")
    print(response)
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  # Update this with the Merchant Center provider ID you want to get the
  # relationship for.
  provider_id_ = 111
  propose_account_service(provider_id_)

Comportamiento del apretón de manos específico del servicio

A continuación, se incluye una descripción de los requisitos específicos del apretón de manos para cada servicio individual:

  • Agregación de cuentas: Este servicio solo se puede establecer como parte de la creación de la cuenta. Se espera que el proveedor de servicios sea una cuenta avanzada, y el servicio se aprueba automáticamente, ya que los usuarios de la cuenta avanzada tienen acceso ADMIN completo a la cuenta que se está creando.

  • Comparación de productos: Este servicio se aprueba automáticamente cuando se agrega durante la creación de la cuenta con createAndConfigure.

  • Administración de campañas: Si bien sigue el proceso normal de apretón de manos, las propuestas se realizan en un sistema (por ejemplo, Google Ads) y las aprobaciones se realizan en el otro sistema (por ejemplo, en Merchant Center o a través de la API de Merchant).

  • Administración de fichas locales: Para este servicio, el apretón de manos se propone en un método dedicado y las aprobaciones se realizan en el otro sistema (por ejemplo, Perfil de Negocio de Google). Los pasos detallados se encuentran en la Guía para vincular un Perfil de Negocio de Google.

  • Administración de cuentas: Para este servicio, el proceso normal de apretón de manos se aplica cuando se usa propose. Si el servicio se agrega durante la creación de la cuenta con createAndConfigure, se aprueba automáticamente.

  • Administración de productos: Para este servicio, se aplica el proceso normal de apretón de manos (una de las partes lo propone y la otra lo acepta).

Derechos de acceso

Cada tipo de servicio proporciona un cierto nivel de acceso para los usuarios del proveedor de servicios sobre la cuenta que se atiende:

  • Agregación de cuentas: Este servicio proporciona derechos ADMIN completos.

  • Administración de campañas: Este servicio proporciona un derecho de acceso restringido, lo que permite que la cuenta de Ads asociada acceda a los productos y a la información básica de la cuenta.

  • Comparación de productos: De forma predeterminada, este servicio proporciona derechos ADMIN completos. Sin embargo, la empresa puede restringir el acceso otorgado en Merchant Center.

  • Administración de fichas locales: Este servicio no proporciona derechos de acceso directos. En cambio, permite que la ficha sincronice sus productos con la cuenta de Merchant Center.

Importante: Los derechos de acceso que se describen para los siguientes tipos de servicios solo se aplican a los proveedores de servicios aprobados. Comunícate con nuestro equipo de asistencia si eres un proveedor de servicios y quieres usar esta capacidad. Si ya se te aprobó el método accounts.link para la administración de productos en Content API for Shopping, puedes usar este servicio en la API de Merchant sin más aprobaciones.

  • Administración de cuentas: De forma predeterminada, este servicio proporciona derechos ADMIN completos.

  • Administración de productos: Este servicio proporciona derechos ADMIN completos. Ten en cuenta que, en el futuro, esto se limitará solo a los derechos de acceso relacionados con los productos.

Cómo se aplican las relaciones para las plataformas de terceros

Si eres una plataforma de terceros que administra cuentas en nombre de otras empresas, a continuación, se muestra cómo se asignan los diferentes conceptos a la estructura de tu cuenta:

  1. Proveedor de servicios: Tu cuenta avanzada.
  2. Cuenta que recibe el servicio: Una cuenta de Merchant Center que representa la empresa que administras.
  3. Servicio:
    • accountManagement: Este es el servicio recomendado para las plataformas de comercio electrónico y los socios de canal que crean cuentas nuevas en nombre de los comercios. Crea una cuenta que es propiedad del comercio y que está vinculada a ti para su administración. Esto se alinea con la estructura preferida de Merchant Center para este caso de uso.
    • accountAggregation: Este servicio vincula tu cuenta avanzada a otra cuenta. Si bien es compatible, no se recomienda para las plataformas de comercio electrónico ni los socios de canal.

Para obtener detalles sobre cómo configurar una cuenta avanzada y vincularla a cuentas nuevas de Merchant Center, consulta Crea cuentas.

Anterior
Create accounts
Siguiente
Control access to your account