Tworzenie kont

Za pomocą interfejsu Merchant API możesz tworzyć konta Merchant Center, które można połączyć z kontem zaawansowanym za pomocą accountAggregation, accountManagement lub comparisonShopping. Metoda accounts.createAndConfigure umożliwia utworzenie konta i opcjonalne skonfigurowanie go za pomocą użytkowników oraz powiązanie go z innymi kontami za pomocą usług.

Z tego przewodnika dowiesz się, jak używać interfejsu API sprzedawcy do tworzenia kont za pomocą usług takich jak accountManagement, comparisonShopping czy accountAggregation. Jeśli używasz parametru accounts.createAndConfigure, musisz połączyć nowe konto z dostawcą, podając w polu service co najmniej jeden z tych atrybutów: accountAggregation, accountManagement lub comparisonShopping. W tym samym żądaniu możesz określić accountAggregation i comparisonShopping, ale accountManagement nie można łączyć z accountAggregation ani z comparisonShopping. Jeśli podasz wartość accountManagement, musisz też dodać co najmniej jednego użytkownika do nowego konta za pomocą pola user lub users.

Wymagania wstępne

Zanim utworzysz konta za pomocą interfejsu Merchant API, sprawdź, czy spełniasz te wymagania w zależności od używanych usług:

  • Dostęp administracyjny: podczas łączenia nowego konta za pomocą accountManagement, comparisonShopping lub accountAggregation musisz mieć dostęp administracyjny do konta dostawcy.
  • Konto zaawansowane: jeśli korzystasz z accountAggregation, Twoje konto dostawcy musi być kontem zaawansowanym skonfigurowanym pod kątem agregacji kont. Jeśli jesteś usługodawcą i chcesz skonfigurować konto zaawansowane, skontaktuj się z zespołem pomocy, aby uzyskać pomoc w konfiguracji.

Tworzenie konta (za pomocą zarządzania kontami lub usługi porównywania cen)

Aby utworzyć nowe konto, wywołaj funkcję accounts.createAndConfigure. Jest to zalecane podejście dla partnerów pomagających sprzedawcom zarządzać kontami, ponieważ umożliwia sprzedawcom zachowanie pełnej kontroli i własności konta przy jednoczesnym przyznaniu partnerom określonych uprawnień.

W treści żądania:

  1. Podaj szczegóły konta, które chcesz utworzyć, w polu account.
  2. Jeśli korzystasz z usługi accountManagement, w polu user określ co najmniej jednego użytkownika, który będzie mieć dostęp do konta.
  3. W polu service określ usługi, które chcesz udostępnić na tym koncie, np. accountManagement, i ustaw wartość provider na nazwę zasobu konta (np. providers/{YOUR_ACCOUNT_ID}). Listę dostępnych usług, takich jak productsManagement czy campaignsManagement, znajdziesz w artykule Zarządzanie relacjami między kontami.

Oto przykładowa prośba o utworzenie konta o nazwie „merchantStore” i połączenie go z kontem {YOUR_ACCOUNT_ID} w celu zarządzania kontem i produktami:

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "user": [
    {
      "userId": "test@example.com",
      "user": {
        "accessRights": ["ADMIN"]
      }
    }
  ],
  "service": [
    {
      "accountManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    },
    {
      "productsManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    }
  ]
}

Prawidłowe wywołanie spowoduje utworzenie nowego konta i połączenie go z Twoim kontem w przypadku określonych usług. Jeśli podczas tworzenia określisz usługi accountManagement, accountAggregation lub comparisonShopping, zostaną one automatycznie zatwierdzone, a stan połączenia będzie ESTABLISHED. Inne połączenia z usługami mogą mieć stan PENDING, dopóki nie zostaną zaakceptowane przez utworzone konto. Treść odpowiedzi zawiera nowo utworzony zasób Account.

Po utworzeniu takiego konta musisz przejść proces rejestracji, wykonując czynności takie jak zaakceptowanie Warunków korzystania z usługi, skonfigurowanie informacji o firmie i zweryfikowanie strony internetowej.

Pomijanie weryfikacji adresu e-mail podczas tworzenia konta

Podczas tworzenia konta w usłudze accounts.createAndConfigure możesz opcjonalnie pominąć wysyłanie e-maili weryfikacyjnych do nowych użytkowników dodanych za pomocą pola user, ustawiając w ich przypadku wartość verificationMailSettings.verificationMailMode na SUPPRESS_VERIFICATION_MAIL w żądaniu. Jest to przydatne, jeśli zamierzasz zweryfikować użytkowników w imieniu sprzedawcy natychmiast po utworzeniu konta za pomocą metody users.verifySelf. Domyślnie wartość verificationMailMode to SEND_VERIFICATION_MAIL, a e-maile weryfikacyjne są wysyłane do nowych użytkowników dodanych podczas tworzenia konta.

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "user": [
    {
      "userId": "test@example.com",
      "user": {
        "accessRights": ["ADMIN"]
      },
      "verificationMailSettings": {
        "verificationMailMode": "SUPPRESS_VERIFICATION_MAIL"
      }
    }
  ],
  "service": [
    {
      "accountManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    }
  ]
}

Jeśli ustawisz wartość verificationMailMode na SUPPRESS_VERIFICATION_MAIL, musisz wywołać funkcję users.verifySelf dla każdego użytkownika dodanego podczas tworzenia, aby dokończyć weryfikację. To wywołanie musi być uwierzytelnione jako użytkownik, który jest weryfikowany (użytkownik określony w userId), na przykład za pomocą tokena OAuth od użytkownika.

Podawanie aliasu podczas tworzenia konta

Możesz określić alias konta w kontekście dostawcy w  CreateAndConfigureAccountRequest za pomocą pola setAlias. Alias może służyć do identyfikowania konta w Twoim systemie. Jeśli jesteś dostawcą usług, możesz użyć aliasu, aby pobrać konto za pomocą GET /accounts/v1/accounts/{provider}~{alias}. Alias musi być unikalny dla danego dostawcy, a w polu service żądania musisz podać usługę tego samego dostawcy. Więcej informacji o wymaganiach dotyczących aliasów znajdziesz w artykule Zarządzanie relacjami między kontami.

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "service": [
    {
      "accountManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    }
  ],
  "setAlias": [
    {
      "provider": "providers/{YOUR_ACCOUNT_ID}",
      "accountIdAlias": "my-merchant-alias"
    }
  ]
}

Jeśli jesteś partnerem, który tworzy konto w imieniu sprzedawcy, zalecamy wykonanie tych czynności:

  1. Utwórz konto: wywołaj funkcję accounts.createAndConfigure, podając dane logowania partnera, aby utworzyć nowe konto.
    • Ustaw parametr service, aby zawierał link accountManagement do identyfikatora dostawcy.
    • Dodaj sprzedawcę jako użytkownika za pomocą pola user i ustaw wartość verificationMailSettings.verificationMailMode na SUPPRESS_VERIFICATION_MAIL.
  2. Weryfikacja użytkownika: za pomocą danych logowania sprzedawcy (np. tokena OAuth) wywołaj funkcję users.verifySelf, aby zmienić stan użytkownika z PENDING na VERIFIED.
  3. Ustaw kraj firmy: za pomocą danych logowania sprzedawcy ustaw kraj firmy, aktualizując address.regionCode za pomocą accounts.updateBusinessInfo. Jest to wymagane przed zaakceptowaniem Warunków korzystania z usługi.
  4. Zaakceptuj Warunki korzystania z usługi: za pomocą danych logowania sprzedawcy zaakceptuj Warunki korzystania z usługi.

Ten proces umożliwia sprzedawcy bezproblemowe rozpoczęcie korzystania z Twojej platformy bez otrzymywania e-maili z zaproszeniem od Google.

Tworzenie konta klienta (za pomocą agregacji kont)

Konta klienta to odrębne konta Merchant Center połączone z kontem zaawansowanym za pomocą usługi accountAggregation, co umożliwia scentralizowane zarządzanie przy zachowaniu oddzielnych ustawień, witryn i plików danych. Do tworzenia nowych kont klientów możesz używać interfejsu Merchant Accounts API.

Aby utworzyć konta klientów, musisz najpierw mieć zaawansowaną konfigurację konta. Aby przekonwertować konto Merchant Center na konto zaawansowane, musisz być administratorem konta. Na koncie nie mogą występować żadne problemy oczekujące na rozwiązanie.

Aby utworzyć nowe konto klienta, wywołaj funkcję accounts.createAndConfigure. W treści żądania:

  1. Podaj szczegóły konta, które chcesz utworzyć, w polu account.
  2. Opcjonalnie możesz określić nowych autoryzowanych użytkowników w polu user. Dostęp użytkowników do konta jest też dziedziczony z nadrzędnego konta zaawansowanego.
  3. W polu service określ accountAggregation i ustaw provider na nazwę zasobu konta zaawansowanego (np. providers/{ADVANCED_ACCOUNT_ID}). Spowoduje to ustawienie konta zaawansowanego jako agregatora nowego konta.

Oto przykładowe żądanie utworzenia konta klienta o nazwie „merchantStore” połączonego z kontem zaawansowanym{ADVANCED_ACCOUNT_ID}:

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "service": [
    {
      "accountAggregation": {},
      "provider": "providers/{ADVANCED_ACCOUNT_ID}"
    }
  ]
}

Prawidłowe wywołanie spowoduje utworzenie nowego konta klienta i połączenie go z określonym kontem zaawansowanym. Treść odpowiedzi będzie zawierała nowo utworzony zasób Account.

Poniższe przykłady pokazują, jak za pomocą parametru accounts.createAndConfigure utworzyć nowe konto klienta.

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.Account;
import com.google.shopping.merchant.accounts.v1.AccountAggregation;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1.CreateAndConfigureAccountRequest;
import com.google.shopping.merchant.accounts.v1.CreateAndConfigureAccountRequest.AddAccountService;
import com.google.type.TimeZone;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to create a sub-account under an advanced account. */
public class CreateSubAccountSample {

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

  public static void createSubAccount(Config config) throws Exception {

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

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

    // Creates parent/provider to identify the advanced account into which to insert the subaccount.
    String parent = getParent(config.getAccountId().toString());

    // Calls the API and catches and prints any network failures/errors.
    try (AccountsServiceClient accountsServiceClient =
        AccountsServiceClient.create(accountsServiceSettings)) {

      CreateAndConfigureAccountRequest request =
          CreateAndConfigureAccountRequest.newBuilder()
              .setAccount(
                  Account.newBuilder()
                      .setAccountName("Demo Business")
                      .setAdultContent(false)
                      .setTimeZone(TimeZone.newBuilder().setId("America/New_York").build())
                      .setLanguageCode("en-US")
                      .build())
              .addService(
                  AddAccountService.newBuilder()
                      .setProvider(parent)
                      .setAccountAggregation(AccountAggregation.getDefaultInstance())
                      .build())
              .build();

      System.out.println("Sending Create SubAccount request");
      Account response = accountsServiceClient.createAndConfigureAccount(request);
      System.out.println("Inserted Account Name below");
      // Format: `accounts/{account}
      System.out.println(response.getName());
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();

    createSubAccount(config);
  }
}
CreateSubAccountSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Account;
use Google\Shopping\Merchant\Accounts\V1\AccountAggregation;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountsServiceClient;
use Google\Shopping\Merchant\Accounts\V1\CreateAndConfigureAccountRequest;
use Google\Shopping\Merchant\Accounts\V1\CreateAndConfigureAccountRequest\AddAccountService;
use Google\Type\TimeZone;

/**
 * This class demonstrates how to create a sub-account under an MCA account.
 */
class CreateSubAccount
{

    private static function getParent(string $accountId): string
    {
        return sprintf("accounts/%s", $accountId);
    }


    public static function createSubAccount(array $config): void
    {
        // Gets the OAuth credentials to make the request.
        $credentials = Authentication::useServiceAccountOrTokenFile();

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

        // Creates a client.
        $accountsServiceClient = new AccountsServiceClient($options);

        // Creates parent/provider to identify the MCA account into which to insert the subaccount.
        $parent = self::getParent($config['accountId']);

        // Calls the API and catches and prints any network failures/errors.
        try {
            $request = new CreateAndConfigureAccountRequest([
                'account' => (new Account([
                    'account_name' => 'Demo Business',
                    'adult_content' => false,
                    'time_zone' => (new TimeZone(['id' => 'America/New_York'])),
                    'language_code' => 'en-US',
                ])),
                'service' => [
                    (new AddAccountService([
                        'provider' => $parent,
                        'account_aggregation' => new AccountAggregation,
                    ])),
                ],
            ]);

            print "Sending Create SubAccount request\n";
            $response = $accountsServiceClient->createAndConfigureAccount($request);
            print "Inserted Account Name below\n";
            // Format: `accounts/{account}
            print $response->getName() . PHP_EOL;
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }
    public function callSample(): void
    {
        $config = Config::generateConfig();
        self::createSubAccount($config);
    }
}

$sample = new CreateSubAccount();
$sample->callSample();
CreateSubAccountSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import Account
from google.shopping.merchant_accounts_v1 import AccountAggregation
from google.shopping.merchant_accounts_v1 import AccountsServiceClient
from google.shopping.merchant_accounts_v1 import CreateAndConfigureAccountRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()


def get_parent(account_id):
  return f"accounts/{account_id}"


def create_sub_account():
  """Creates a sub-account under an advanced account."""

  # Get OAuth credentials.
  credentials = generate_user_credentials.main()

  # Create a client.
  client = AccountsServiceClient(credentials=credentials)

  # Get the parent advanced account ID.
  parent = get_parent(_ACCOUNT)

  # Create the request.
  request = CreateAndConfigureAccountRequest(
      account=Account(
          account_name="Demo Business",
          adult_content=False,
          time_zone={"id": "America/New_York"},
          language_code="en-US",
      ),
      service=[
          CreateAndConfigureAccountRequest.AddAccountService(
              provider=parent,
              account_aggregation=AccountAggregation(),
          )
      ],
  )

  # Make the request and print the response.
  try:
    print("Sending Create SubAccount request")
    response = client.create_and_configure_account(request=request)
    print("Inserted Account Name below")
    print(response.name)
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  create_sub_account()

create_sub_account_sample.py

cURL

curl -X POST \
"https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure" \
-H "Authorization: Bearer <YOUR_ACCESS_TOKEN>" \
-H "Content-Type: application/json" \
-d '{
  "account": {
    "accountName": "Demo Business",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "service": [
    {
      "accountAggregation": {},
      "provider": "providers/{ADVANCED_ACCOUNT_ID}"
    }
  ]
}'

Pobieranie kont klientów

Aby wyświetlić listę wszystkich kont klientów danego konta zaawansowanego, użyj metody accounts.listSubaccounts. W provider pola adresu URL żądania wpisz identyfikator konta zaawansowanego.

Przykładowe żądanie:

GET https://merchantapi.googleapis.com/accounts/v1/accounts/{ADVANCED_ACCOUNT_ID}:listSubaccounts

Oto przykładowa odpowiedź po udanym wywołaniu:

{
"accounts": [
    {
      "name": "accounts/<var class=\"readonly\">{SUB_ACCOUNT_ID_1}</var>",
      "accountId": "<var class=\"readonly\">{SUB_ACCOUNT_ID_1}</var>",
      "accountName": "<var class=\"readonly\">{SUB_ACCOUNT_NAME_1}</var>",
      "timeZone": {
        "id": "America/Los_Angeles"
      },
      "languageCode": "en-US"
    },
    {
      "name": "accounts/<var class=\"readonly\">{SUB_ACCOUNT_ID_2}</var>",
      "accountId": "<var class=\"readonly\">{SUB_ACCOUNT_ID_2}</var>",
      "accountName": "<var class=\"readonly\">{SUB_ACCOUNT_NAME_2}</var>",
      "timeZone": {
        "id": "America/Los_Angeles"
      },
      "languageCode": "en-US"
    }
  ]
}

Poniższe przykłady pokazują, jak wyświetlić listę wszystkich kont klientów na koncie zaawansowanym.

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.Account;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient.ListSubAccountsPagedResponse;
import com.google.shopping.merchant.accounts.v1.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1.ListSubAccountsRequest;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to list all the subaccounts of an advanced account. */
public class ListSubAccountsSample {

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

  public static void listSubAccounts(Config config) throws Exception {

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

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

    // Creates parent/provider to identify the advanced account from which to list all sub-accounts.
    String parent = getParent(config.getAccountId().toString());

    // Calls the API and catches and prints any network failures/errors.
    try (AccountsServiceClient accountsServiceClient =
        AccountsServiceClient.create(accountsServiceSettings)) {

      // The parent has the format: accounts/{account}
      ListSubAccountsRequest request =
          ListSubAccountsRequest.newBuilder().setProvider(parent).build();
      System.out.println("Sending list subaccounts request:");

      ListSubAccountsPagedResponse response = accountsServiceClient.listSubAccounts(request);

      int count = 0;

      // Iterates over all rows in all pages and prints the datasource in each row.
      // Automatically uses the `nextPageToken` if returned to fetch all pages of data.
      for (Account account : response.iterateAll()) {
        System.out.println(account);
        count++;
      }
      System.out.print("The following count of accounts were returned: ");
      System.out.println(count);
    } catch (Exception e) {
      System.out.println("An error has occured: ");
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    listSubAccounts(config);
  }
}
ListSubAccountsSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountsServiceClient;
use Google\Shopping\Merchant\Accounts\V1\ListSubAccountsRequest;

/**
 * This class demonstrates how to list all the subaccounts of an advanced account.
 */
class ListSubAccounts
{
    private static function getParent(string $accountId): string
    {
        return sprintf("accounts/%s", $accountId);
    }


    public static function listSubAccounts(array $config): void
    {
        // Gets the OAuth credentials to make the request.
        $credentials = Authentication::useServiceAccountOrTokenFile();

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

        // Creates a client.
        $accountsServiceClient = new AccountsServiceClient($options);

        // Creates parent/provider to identify the advanced account from which
        //to list all accounts.
        $parent = self::getParent($config['accountId']);

        // Calls the API and catches and prints any network failures/errors.
        try {

            // The parent has the format: accounts/{account}
            $request = new ListSubAccountsRequest(['provider' => $parent]);
            print "Sending list subaccounts request:\n";

            $response = $accountsServiceClient->listSubAccounts($request);

            $count = 0;

            // Iterates over all rows in all pages and prints the datasource in each row.
            // Automatically uses the `nextPageToken` if returned to fetch all pages of data.
            foreach ($response->iterateAllElements() as $account) {
                print_r($account);
                $count++;
            }
            print "The following count of accounts were returned: ";
            print $count . PHP_EOL;
        } catch (ApiException $e) {
            print "An error has occured: \n";
            print $e->getMessage();
        }
    }

    public function callSample(): void
    {
        $config = Config::generateConfig();
        self::listSubAccounts($config);
    }
}

$sample = new ListSubAccounts();
$sample->callSample();
ListSubAccountsSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AccountsServiceClient
from google.shopping.merchant_accounts_v1 import ListSubAccountsRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()


def get_parent(account_id):
  return f"accounts/{account_id}"


def list_sub_accounts():
  """Lists all the subaccounts of an advanced account."""

  # Get OAuth credentials.
  credentials = generate_user_credentials.main()

  # Create a client.
  client = AccountsServiceClient(credentials=credentials)

  # Get the parent advanced account ID.
  parent = get_parent(_ACCOUNT)

  # Create the request.
  request = ListSubAccountsRequest(provider=parent)

  # Make the request and print the response.
  try:
    print("Sending list subaccounts request:")
    response = client.list_sub_accounts(request=request)

    count = 0
    for account in response:
      print(account)
      count += 1

    print(f"The following count of accounts were returned: {count}")

  except RuntimeError as e:
    print("An error has occured: ")
    print(e)


if __name__ == "__main__":
  list_sub_accounts()

list_sub_accounts_sample.py

cURL

curl -X GET \
"https://merchantapi.googleapis.com/accounts/v1/accounts/{ADVANCED_ACCOUNT_ID}:listSubaccounts" \
-H "Authorization: Bearer <YOUR_ACCESS_TOKEN>"

Usuwanie konta klienta

Jeśli nie chcesz już zarządzać kontem klienta, możesz je usunąć za pomocą metody accounts.delete.

Wykonanie tej metody wymaga dostępu administratora do usuwanego konta.

Przykładowe żądanie:

DELETE https://merchantapi.googleapis.com/accounts/v1/accounts/{SUB_ACCOUNT_ID}

Jeśli operacja się uda, treść odpowiedzi będzie zawierała pusty obiekt JSON, co oznacza, że konto zostało usunięte.

Poniższe przykłady pokazują, jak usunąć konto klienta.

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.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1.DeleteAccountRequest;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to delete a given Merchant Center account. */
public class DeleteAccountSample {

  // This method can delete a standalone, advanced account or sub-account. If you delete an advanced
  // account,
  // all sub-accounts will also be deleted.
  // Admin user access is required to execute this method.

  public static void deleteAccount(Config config) throws Exception {

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

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

    // Gets the account ID from the config file.
    String accountId = config.getAccountId().toString();

    // Creates account name to identify the account.
    String name =
        AccountName.newBuilder()
            .setAccount(accountId)
            .build()
            .toString();

    // Calls the API and catches and prints any network failures/errors.
    try (AccountsServiceClient accountsServiceClient =
        AccountsServiceClient.create(accountsServiceSettings)) {
      DeleteAccountRequest request =
          DeleteAccountRequest.newBuilder()
              .setName(name)
              // Optional. If set to true, the account will be deleted even if it has offers or
              // provides services to other accounts. Defaults to 'false'.
              .setForce(true)
              .build();

      System.out.println("Sending Delete Account request");
      accountsServiceClient.deleteAccount(request); // No response returned on success.
      System.out.println("Delete successful.");
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    deleteAccount(config);
  }
}
DeleteAccountSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountsServiceClient;
use Google\Shopping\Merchant\Accounts\V1\DeleteAccountRequest;


/**
 * This class demonstrates how to delete a given Merchant Center account.
 */
class DeleteAccount
{
    private static function getParent(string $accountId): string
    {
        return sprintf("accounts/%s", $accountId);
    }

    // This method can delete a standalone, advanced account or sub-account.
    // If you delete an advanced account, all sub-accounts will also be deleted.
    // Admin user access is required to execute this method.
    public static function deleteAccount(array $config): void
    {
        // Gets the OAuth credentials to make the request.
        $credentials = Authentication::useServiceAccountOrTokenFile();

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

        // Creates a client.
        $accountsServiceClient = new AccountsServiceClient($options);


        // Gets the account ID from the config file.
        $accountId = $config['accountId'];

        // Creates account name to identify the account.
        $name = self::getParent($accountId);

        // Calls the API and catches and prints any network failures/errors.
        try {
            $request = new DeleteAccountRequest([
                'name' => $name,
                // Optional. If set to true, the account will be deleted even if it has offers or
                // provides services to other accounts. Defaults to 'false'.
                'force' => true,
            ]);

            print "Sending Delete Account request\n";
            $accountsServiceClient->deleteAccount($request); // No response returned on success.
            print "Delete successful.\n";
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }

    public function callSample(): void
    {
        $config = Config::generateConfig();
        self::deleteAccount($config);
    }
}

$sample = new DeleteAccount();
$sample->callSample();
DeleteAccountSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AccountsServiceClient
from google.shopping.merchant_accounts_v1 import DeleteAccountRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()


def get_parent(account_id):
  return f"accounts/{account_id}"


def delete_account():
  """Deletes a given Merchant Center account."""

  # Get OAuth credentials.
  credentials = generate_user_credentials.main()

  # Create a client.
  client = AccountsServiceClient(credentials=credentials)

  # Create the account name.
  name = get_parent(_ACCOUNT)

  # Create the request.
  request = DeleteAccountRequest(name=name, force=True)

  # Make the request and print the response.
  try:
    print("Sending Delete Account request")
    client.delete_account(request=request)
    print("Delete successful.")
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  delete_account()

delete_account_sample.py

cURL

curl -X DELETE \
"https://merchantapi.googleapis.com/accounts/v1/accounts/{SUB_ACCOUNT_ID}?force=true" \
-H "Authorization: Bearer <YOUR_ACCESS_TOKEN>"

Zaakceptuj Warunki korzystania z usługi

Konta klientów dziedziczą Warunki korzystania z usługi Merchant Center, które zostały podpisane przez nadrzędne konto zaawansowane.

Aktualizowanie informacji o firmie

Za pomocą interfejsu Merchant Accounts API możesz edytować informacje o firmie na kontach klientów.

Wstecz
Overview
Dalej
Manage Terms of Service