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 z użytkownikami oraz połączenie z innymi kontami za pomocą usług.

Z tego przewodnika dowiesz się, jak używać interfejsu Merchant API do tworzenia kont za pomocą usług takich jak accountManagement, comparisonShopping lub accountAggregation. Gdy używasz metody accounts.createAndConfigure, musisz połączyć nowe konto z aprowizatorem, określając w polu service co najmniej jedną z tych usług: accountAggregation, accountManagement lub comparisonShopping. W tym samym żądaniu możesz określić usługi accountAggregation i comparisonShopping, ale usługi accountManagement nie można łączyć z usługami accountAggregation ani comparisonShopping. Jeśli określisz usługę accountManagement, musisz też dodać do nowego konta co najmniej 1 użytkownika za pomocą pola user lub users.

Wymagania wstępne

Zanim zaczniesz tworzyć konta za pomocą interfejsu Merchant API, upewnij się, że spełniasz te wymagania w zależności od używanych usług:

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

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

Aby utworzyć nowe konto, wywołaj metodę accounts.createAndConfigure. Jest to zalecane rozwiązanie dla partnerów, którzy pomagają sprzedawcom zarządzać kontami, ponieważ umożliwia sprzedawcom zachowanie pełnej kontroli i własności konta, a jednocześnie przyznanie partnerom określonych uprawnień.

W treści żądania:

  1. W polu account podaj szczegóły konta, które chcesz utworzyć.
  2. W polu accountName nie używaj powtarzających się ani niepotrzebnych znaków interpunkcyjnych, wielkich liter, podkreśleń, samych wielkich liter, emoji ani symboli innych niż alfanumeryczne, takich jak / czy _. Unikaj sufiksów firmowych (np. „sp. z o.o.” lub „GmbH”), tekstów promocyjnych, danych osobowych i nieodpowiednich sformułowań. Użyj krótkiej, jasnej i profesjonalnej nazwy. Więcej informacji znajdziesz w artykule o dodawaniu nazwy firmy.
  3. Jeśli używasz usługi accountManagement, w polu user określ co najmniej 1 użytkownika, który będzie mieć dostęp do konta.
  4. W polu service określ usługi, które chcesz świadczyć na tym koncie, np. accountManagement, i ustaw wartość provider na nazwę zasobu Twojego 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ładowe żądanie utworzenia konta o nazwie „merchantStore” i połączenia go z kontem {YOUR_ACCOUNT_ID} na potrzeby 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}"
    }
  ]
}

Pomyślne wywołanie tworzy nowe konto i łączy je 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 usług mogą mieć stan PENDING, dopóki nie zostaną zaakceptowane przez utworzone konto. Treść odpowiedzi zawiera nowo utworzony Account zasób.

Po utworzeniu takiego konta musisz je skonfigurować, wykonując takie czynności jak zaakceptowanie Warunków korzystania z usługi , skonfigurowanie informacji o firmie, i zweryfikowanie witryny.

Pomijanie weryfikacji adresu e-mail podczas tworzenia konta

Podczas tworzenia konta za pomocą metody accounts.createAndConfigure możesz opcjonalnie pominąć wysyłanie e-maili weryfikacyjnych do nowych użytkowników dodanych za pomocą pola user, ustawiając w żądaniu dla tego użytkownika wartość verificationMailSettings.verificationMailMode na SUPPRESS_VERIFICATION_MAIL. Jest to przydatne, jeśli zamierzasz zweryfikować użytkowników w imieniu sprzedawcy bezpośrednio 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ć metodę users.verifySelf dla każdego użytkownika dodanego podczas tworzenia konta, aby dokończyć weryfikację. To wywołanie musi być uwierzytelnione jako weryfikowany użytkownik (użytkownik określony w polu userId), np. za pomocą tokena OAuth od użytkownika.

Określanie aliasu podczas tworzenia konta

W kontekście dostawcy możesz określić alias konta w polu setAlias w polu CreateAndConfigureAccountRequest. Alias może służyć do identyfikowania konta w Twoim systemie. Jeśli jesteś usługodawcą, możesz użyć aliasu, aby pobrać konto za pomocą metody GET /accounts/v1/accounts/{provider}~{alias}. Alias musi być unikalny dla danego dostawcy, a w polu service żądania musisz określić usługę z tym samym dostawcą. 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 metodę accounts.createAndConfigure z danymi logowania partnera, aby utworzyć nowe konto.
    • Ustaw wartość service tak, aby obejmowała usługę accountManagement łączącą się z Twoim identyfikatorem dostawcy.
    • Dodaj sprzedawcę jako użytkownika za pomocą pola user i ustaw wartość verificationMailSettings.verificationMailMode na SUPPRESS_VERIFICATION_MAIL.
  2. Zweryfikuj użytkownika: za pomocą danych logowania sprzedawcy (np. używając tokena OAuth) wywołaj metodę 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 wartość 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 wprowadzenie na Twojej platformie bez otrzymywania e-maili z zaproszeniem od Google.

Tworzenie konta klienta (za pomocą usługi agregacji kont)

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

Aby utworzyć konta klientów, musisz najpierw skonfigurować konto zaawansowane . Aby przekształcić konto Merchant Center w konto zaawansowane, musisz być administratorem konta, a na koncie nie mogą występować żadne nierozwiązane problemy.

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

  1. W polu account podaj szczegóły konta, które chcesz utworzyć.
  2. W polu accountName nie używaj powtarzających się ani niepotrzebnych znaków interpunkcyjnych, wielkich liter, podkreśleń ani symboli innych niż alfanumeryczne (np. „/” lub „_”). Unikaj sufiksów firmowych (np. „sp. z o.o.” lub „GmbH”), tekstów promocyjnych, danych osobowych i nieodpowiednich sformułowań. Użyj krótkiej, jasnej i profesjonalnej nazwy. Więcej informacji znajdziesz w artykule o dodawaniu nazwy firmy.
  3. Opcjonalnie w polu user określ nowych autoryzowanych użytkowników. Dostęp użytkowników do konta jest też dziedziczony z nadrzędnego konta zaawansowanego.
  4. W service polu określ accountAggregation i ustaw wartość provider na nazwę zasobu Twojego konta zaawansowanego (np. providers/{ADVANCED_ACCOUNT_ID}). Dzięki temu Twoje konto zaawansowane będzie agregatorem 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}"
    }
  ]
}

Pomyślne wywołanie tworzy nowe konto klienta i łączy je z określonym kontem zaawansowanym. Treść odpowiedzi będzie zawierała nowo utworzony Account zasób.

Z tych przykładów dowiesz się, jak utworzyć nowe konto klienta za pomocą metody accounts.createAndConfigure.

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);
  }
}

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();

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()

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 accounts.listSubaccounts metody. W polu provider adresu URL żądania podaj identyfikator konta zaawansowanego.

Oto przykładowe żądanie:

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

Oto przykładowa odpowiedź na pomyślne wywołanie:

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

Z tych przykładów dowiesz się, 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);
  }
}

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();

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()

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 musisz już zarządzać kontem klienta, możesz je usunąć za pomocą metody accounts.delete.

Aby wykonać tę metodę, musisz mieć dostęp administratora do usuwanego konta.

Oto 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.

Z tych przykładów dowiesz się, 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);
  }
}

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();

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()

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 (TOS) które zostały zaakceptowane przez nadrzędne konto zaawansowane.

Aktualizacja informacji o firmie

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

Wstecz
Overview
Dalej
Account relationships