Zarządzanie umowami dotyczącymi Warunków korzystania z usługi Merchant Center

Aby korzystać z Merchant Center i jego funkcji, musisz zaakceptować Warunki korzystania z usługi Merchant Center w przypadku lokalizacji Twojej firmy. Te umowy określają warunki prawne korzystania z usług Merchant Center.

Z tego przewodnika dowiesz się, jak zarządzać tymi umowami za pomocą interfejsu Merchant API, zarówno na własnym koncie, jak i na kontach, którymi zarządzasz jako dostawca zewnętrzny.

Możesz:

  • Sprawdź bieżący stan umowy dotyczącej warunków korzystania z usługi na koncie.
  • pomagać sprzedawcom w akceptowaniu niezbędnych Warunków korzystania z usługi;
  • zarządzać Warunkami korzystania z usługi jako dostawca usług w przypadku kont klientów;

Wymagania wstępne

Aby korzystać z interfejsu Merchant API, musisz mieć konto Merchant Center. Po utworzeniu konta za pomocą interfejsu użytkownika Merchant Center możesz wprowadzać zmiany na koncie (np. aktualizować informacje o firmie, zarządzać użytkownikami itp.) za pomocą interfejsu użytkownika lub interfejsu API.

Jeśli musisz zarządzać wieloma kontami, możesz utworzyć konta klientów za pomocą interfejsu Merchant API. Zobacz Tworzenie kont.

Sprawdzanie stanu akceptacji Warunków korzystania z usługi na koncie

Zanim sprzedawca będzie mógł w pełni korzystać z Merchant Center lub jeśli musisz sprawdzić stan jego obecnej umowy, możesz pobrać stan jego umowy dotyczącej Warunków korzystania z usługi.

Użyj metody termsOfServiceAgreementStates.retrieveForApplication aby uzyskać stan umowy z warunkami usługi dla podstawowej aplikacji Merchant Center. Ta metoda zwraca aktualne Warunki korzystania z usługi (jeśli takie istnieją) oraz, jeśli Warunki korzystania z usługi zostały zaktualizowane od czasu ostatniej akceptacji, najnowszą wersję, którą musisz zaakceptować.

Przykładowe żądanie:

GET https://merchantapi.googleapis.com/accounts/v1/accounts/{ACCOUNT_ID}/termsOfServiceAgreementStates:retrieveForApplication

Pomyślne wywołanie zwraca zasób TermsOfServiceAgreementState. Ten zasób zawiera:

  • name: Identyfikator tego stanu umowy.
  • regionCode: kraj, w którym obowiązuje stan umowy, zwykle kraj, w którym znajduje się firma, do której należy konto.
  • termsOfServiceKind: Będzie to MERCHANT_CENTER.
  • accepted: szczegóły dotyczące wersji warunków usługi, które zostały już zaakceptowane przez konto, w tym termsOfService nazwa zasobu (np. termsOfService/132) i informacja o tym, kto acceptedBy. Może też zawierać validUntil datę, jeśli required nowsza wersja Warunków korzystania z usługi jest dostępna.
  • required: szczegóły wersji Warunków usługi, które konto musi zaakceptować. Obejmuje to nazwę zasobu termsOfService i wartość tosFileUri wskazującą dokument ToS w formacie czytelnym dla człowieka.

Przykładowa odpowiedź:

{
  "name": "accounts/{ACCOUNT_ID}/termsOfServiceAgreementStates/MERCHANT_CENTER-{REGION_CODE}",
  "regionCode": "{REGION_CODE}",
  "termsOfServiceKind": "MERCHANT_CENTER",
  "accepted": {
    "termsOfService": "termsOfService/132",
    "acceptedBy": "accounts/{ACCOUNT_ID}"
  },
  "required": {
    "termsOfService": "termsOfService/132",
    "tosFileUri": "https://www.google.com/intl/{REGION_CODE}/policies/merchants/terms/"
  }
}

Jeśli nowe Warunki korzystania z usługi są required, poproś sprzedawcę o ich zaakceptowanie.

Oto przykładowy kod, którego możesz użyć, aby pobrać stan umowy dotyczącej Warunków korzystania z usługi dla konkretnego konta i kraju:

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.GetTermsOfServiceAgreementStateRequest;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementState;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementStateName;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementStateServiceClient;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceAgreementStateServiceSettings;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/**
 * This class demonstrates how to get a TermsOfServiceAgreementState for a specific
 * TermsOfServiceKind and country.
 */
public class GetTermsOfServiceAgreementStateSample {

  public static void getTermsOfServiceAgreementState(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.
    TermsOfServiceAgreementStateServiceSettings termsOfServiceAgreementStateServiceSettings =
        TermsOfServiceAgreementStateServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Creates TermsOfServiceAgreementState name to identify TermsOfServiceAgreementState.
    String name =
        TermsOfServiceAgreementStateName.newBuilder()
            .setAccount(config.getAccountId().toString())
            // The Identifier is: "{TermsOfServiceKind}-{country}"
            .setIdentifier("MERCHANT_CENTER-US")
            .build()
            .toString();

    System.out.println(name);

    // Calls the API and catches and prints any network failures/errors.
    try (TermsOfServiceAgreementStateServiceClient termsOfServiceAgreementStateServiceClient =
        TermsOfServiceAgreementStateServiceClient.create(
            termsOfServiceAgreementStateServiceSettings)) {

      // The name has the format:
      // accounts/{account}/termsOfServiceAgreementStates/{TermsOfServiceKind}-{country}
      GetTermsOfServiceAgreementStateRequest request =
          GetTermsOfServiceAgreementStateRequest.newBuilder().setName(name).build();

      System.out.println("Sending Get TermsOfServiceAgreementState request:");
      TermsOfServiceAgreementState response =
          termsOfServiceAgreementStateServiceClient.getTermsOfServiceAgreementState(request);

      System.out.println("Retrieved TermsOfServiceAgreementState below");
      // If the terms of service needs to be accepted, the "required" field will include the
      // specific version of the terms of service which needs to be accepted, alongside a link to
      // the terms of service itself.
      System.out.println(response);
    } catch (Exception e) {
      System.out.println(e);
    }
  }


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

    getTermsOfServiceAgreementState(config);
  }
}
GetTermsOfServiceAgreementStateSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Client\TermsOfServiceAgreementStateServiceClient;
use Google\Shopping\Merchant\Accounts\V1\GetTermsOfServiceAgreementStateRequest;

/**
 * Demonstrates how to get a TermsOfServiceAgreementState.
 */
class GetTermsOfServiceAgreementState
{

    /**
     * Gets a TermsOfServiceAgreementState.
     *
     * @param array $config The configuration data.
     * @return void
     */
    public static function getTermsOfServiceAgreementState($config): void
    {
        // Get OAuth credentials.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Create client options.
        $options = ['credentials' => $credentials];

        // Create a TermsOfServiceAgreementStateServiceClient.
        $termsOfServiceAgreementStateServiceClient = new TermsOfServiceAgreementStateServiceClient($options);

        // Service agreeement identifier
        $identifier = "MERCHANT_CENTER-US";

        // Create TermsOfServiceAgreementState name.
        $name = "accounts/" . $config['accountId'] . "/termsOfServiceAgreementStates/" . $identifier;

        print $name . PHP_EOL;

        try {
            // Prepare the request.
            $request = new GetTermsOfServiceAgreementStateRequest([
                'name' => $name,
            ]);

            print "Sending Get TermsOfServiceAgreementState request:" . PHP_EOL;
            $response = $termsOfServiceAgreementStateServiceClient->getTermsOfServiceAgreementState($request);

            print "Retrieved TermsOfServiceAgreementState below\n";
            print $response->serializeToJsonString() . PHP_EOL;
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }

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

        self::getTermsOfServiceAgreementState($config);
    }

}

// Run the script
$sample = new GetTermsOfServiceAgreementState();
$sample->callSample();
GetTermsOfServiceAgreementStateSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import GetTermsOfServiceAgreementStateRequest
from google.shopping.merchant_accounts_v1 import TermsOfServiceAgreementStateServiceClient

# Replace with your actual value.
_ACCOUNT_ID = configuration.Configuration().read_merchant_info()
_IDENTIFIER = "MERCHANT_CENTER-US"  # Replace with your identifier


def get_terms_of_service_agreement_state():
  """Gets a TermsOfServiceAgreementState for a specific TermsOfServiceKind and country."""

  credentials = generate_user_credentials.main()
  client = TermsOfServiceAgreementStateServiceClient(credentials=credentials)

  name = (
      "accounts/"
      + _ACCOUNT_ID
      + "/termsOfServiceAgreementStates/"
      + _IDENTIFIER
  )

  print(name)

  request = GetTermsOfServiceAgreementStateRequest(name=name)

  try:
    print("Sending Get TermsOfServiceAgreementState request:")
    response = client.get_terms_of_service_agreement_state(request=request)
    print("Retrieved TermsOfServiceAgreementState below")
    print(response)
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  get_terms_of_service_agreement_state()

get_terms_of_service_agreement_state_sample.py

Zaakceptuj warunki korzystania z usługi

Aby zachować dostęp do funkcji Merchant Center, sprzedawcy muszą zaakceptować najnowsze Warunki korzystania z usługi.

Akceptowanie Warunków korzystania z usługi na własnym koncie

Jeśli zarządzasz własnym kontem Merchant Center, wykonaj te czynności:

  1. Zadzwoń pod numer termsOfServiceAgreementStates.retrieveForApplication, aby sprawdzić, czy któreś z warunków korzystania z usługi są required.
  2. Jeśli wymagane są Warunki korzystania z usługi, zanotuj nazwę termsOfService z pola required (np. termsOfService/132).

  3. Zadzwoń pod numer termsOfService.accept, aby zaakceptować Warunki korzystania z usługi. Będziesz potrzebować nazwy Warunków korzystania z usługi, swojego ACCOUNT_ID i regionCode zwróconego przez funkcję retrieveForApplication.

    Przykładowe żądanie:

    POST https://merchantapi.googleapis.com/accounts/v1/{name={termsOfService/VERSION}}:accept
{
  "account": "accounts/{ACCOUNT_ID}",
  "regionCode": "{REGION_CODE}"
}

    Pomyślne wywołanie zwraca pustą treść odpowiedzi i aktualizuje stan zgody na warunki usługi na koncie.

Wskazówki dla sprzedawców dotyczące akceptowania Warunków korzystania z usługi (dla dostawców zewnętrznych)

Jeśli jesteś dostawcą zewnętrznym (3P) zarządzającym kontami Merchant Center innych firm, nie możesz akceptować Warunków korzystania z usługi w ich imieniu. Zamiast tego:

  1. Pobierz najnowsze Warunki korzystania z usługi: wywołaj termsOfService.retrieveLatest dla typu regionCode i MERCHANT_CENTER sprzedawcy, aby uzyskać szczegóły najnowszej wersji Warunków korzystania z usługi, które sprzedawca może zaakceptować.

    Przykładowe żądanie:

    GET https://merchantapi.googleapis.com/accounts/v1/termsOfService:retrieveLatest?regionCode={REGION_CODE}&kind=MERCHANT_CENTER

    Przykładowa odpowiedź:

    {
    "name": "{termsOfService/VERSION}",
    "regionCode": "{REGION_CODE}",
    "kind": "MERCHANT_CENTER",
    "fileUri": "https://www.google.com/intl/{REGION_CODE}/policies/merchants/terms/"
}

  2. Wyświetl warunki usługi: użyj parametru fileUri z odpowiedzi, aby wyświetlić sprzedawcy pełny tekst Warunków usługi w interfejsie aplikacji.

  3. Uzyskanie zgody sprzedawcy: sprzedawca musi wyraźnie zaakceptować warunki w interfejsie.

  4. Zarejestruj akceptację za pomocą interfejsu API: po zaakceptowaniu przez sprzedawcę wywołaj termsOfService.accept za pomocą name Warunków korzystania z usługi uzyskanych w kroku 1, ACCOUNT_ID sprzedawcy i jego regionCode.

    Przykładowe żądanie:

    POST https://merchantapi.googleapis.com/accounts/v1/{name={termsOfService/VERSION}}:accept
{
  "account": "accounts/{MERCHANT_ACCOUNT_ID}",
  "regionCode": "{REGION_CODE}"
}

Oto przykładowy kod, którego możesz użyć, aby zaakceptować warunki korzystania z usługi dla danego konta (po zaakceptowaniu ich przez sprzedawcę):

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.AcceptTermsOfServiceRequest;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceServiceClient;
import com.google.shopping.merchant.accounts.v1.TermsOfServiceServiceSettings;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to accept the TermsOfService agreement in a given account. */
public class AcceptTermsOfServiceSample {

  public static void acceptTermsOfService(String accountId, String tosVersion, String regionCode)
      throws Exception {

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

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

    // Calls the API and catches and prints any network failures/errors.
    try (TermsOfServiceServiceClient tosServiceClient =
        TermsOfServiceServiceClient.create(tosServiceSettings)) {

      // The parent has the format: accounts/{account}
      AcceptTermsOfServiceRequest request =
          AcceptTermsOfServiceRequest.newBuilder()
              .setName(String.format("termsOfService/%s", tosVersion))
              .setAccount(String.format("accounts/%s", accountId))
              .setRegionCode(regionCode)
              .build();

      System.out.println("Sending request to accept terms of service...");
      tosServiceClient.acceptTermsOfService(request);

      System.out.println("Successfully accepted terms of service.");
    } catch (Exception e) {
      System.out.println(e);
    }
  }

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

    // See GetTermsOfServiceAgreementStateSample to understand how to check which version of the
    // terms of service needs to be accepted, if any.
    // Likewise, if you know that the terms of service needs to be accepted, you can also simply
    // call RetrieveLatestTermsOfService to get the latest version of the terms of service.
    // Region code is either a country when the ToS applies specifically to that country or 001 when
    // it applies globally.
    acceptTermsOfService(config.getAccountId().toString(), "VERSION_HERE", "REGION_CODE_HERE");
  }
}
AcceptTermsOfServiceSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\AcceptTermsOfServiceRequest;
use Google\Shopping\Merchant\Accounts\V1\Client\TermsOfServiceServiceClient;

/**
 * Demonstrates how to accept the TermsOfService agreement in a given account.
 */
class AcceptTermsOfService
{

    /**
     * Accepts the Terms of Service agreement.
     *
     * @param string $accountId The account ID.
     * @param string $tosVersion The Terms of Service version.
     * @param string $regionCode The region code.
     * @return void
     */
    public static function acceptTermsOfService($accountId, $tosVersion, $regionCode): void
    {
        // Get OAuth credentials.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Create client options.
        $options = ['credentials' => $credentials];

        // Create a TermsOfServiceServiceClient.
        $tosServiceClient = new TermsOfServiceServiceClient($options);

        try {
            // Prepare the request.
            $request = new AcceptTermsOfServiceRequest([
                'name' => sprintf("termsOfService/%s", $tosVersion),
                'account' => sprintf("accounts/%s", $accountId),
                'region_code' => $regionCode,
            ]);

            print "Sending request to accept terms of service...\n";
            $tosServiceClient->acceptTermsOfService($request);

            print "Successfully accepted terms of service.\n";
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }

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

        // Replace with actual values.
        $tosVersion = "132";
        $regionCode = "US";

        self::acceptTermsOfService($config['accountId'], $tosVersion, $regionCode);
    }
}

// Run the script
$sample = new AcceptTermsOfService();
$sample->callSample();
AcceptTermsOfServiceSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AcceptTermsOfServiceRequest
from google.shopping.merchant_accounts_v1 import TermsOfServiceServiceClient

# Replace with your actual values.
_ACCOUNT_ID = configuration.Configuration().read_merchant_info()
_TOS_VERSION = (  # Replace with the Terms of Service version to accept
    "VERSION_HERE"
)
_REGION_CODE = "US"  # Replace with the region code


def accept_terms_of_service():
  """Accepts the Terms of Service agreement for a given account."""

  credentials = generate_user_credentials.main()
  client = TermsOfServiceServiceClient(credentials=credentials)

  # Construct the request
  request = AcceptTermsOfServiceRequest(
      name=f"termsOfService/{_TOS_VERSION}",
      account=f"accounts/{_ACCOUNT_ID}",
      region_code=_REGION_CODE,
  )

  try:
    print("Sending request to accept terms of service...")
    client.accept_terms_of_service(request=request)
    print("Successfully accepted terms of service.")
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  accept_terms_of_service()

accept_terms_of_service_sample.py

Specjalne uwagi dla dostawców zewnętrznych

Jako dostawca zewnętrzny możesz zarządzać Warunkami korzystania z usługi na kontach klientów.

Zarządzanie warunkami korzystania z usługi na kontach klientów

Jeśli zarządzasz kontem zaawansowanym i tworzysz konta klientów dla różnych firm:

  • Zaawansowana akceptacja warunków korzystania z usługi: jeśli konto zaawansowane udostępnia usługę agregacji kont kontom klientów, warunki korzystania z usługi zaakceptowane przez konto zaawansowane będą obowiązywać również w przypadku wszystkich kont klientów korzystających z tej usługi.
  • Wyświetlanie i zgoda: nawet jeśli akceptacja warunków na koncie zaawansowanym obejmuje konta klientów, warto (a może nawet jest to wymagane przez prawo) wyświetlać odpowiednie Warunki korzystania z Google Merchant Center właścicielowi każdej takiej firmy. Musisz uzyskać ich wyraźną zgodę na to, że rozumieją te warunki i je akceptują, nawet jeśli wywołanie interfejsu API w celu zaakceptowania warunków jest wykonywane na poziomie konta zaawansowanego.
  • Sprawdzanie stanu konta klienta: użyj termsOfServiceAgreementStates.retrieveForApplication na konkretnym koncie klienta, aby sprawdzić jego stan w zakresie Warunków korzystania z usługi i dowiedzieć się, czy jest ono objęte umową konta zaawansowanego, czy też wymagane jest podjęcie bezpośrednich działań.

Zarządzanie warunkami korzystania z usługi na innych kontach

Zgodnie z informacjami w tym przewodniku, gdy pomagasz firmie w utworzeniu lub zarządzaniu jej kontem, musi ona (właściciel konta) osobiście zaakceptować Warunki usługi. Aby to zrobić, musisz pobrać i wyświetlić Warunki korzystania z usługi, a następnie wywołać metodę termsOfService.accept w imieniu użytkownika po uzyskaniu jego wyraźnej zgody w interfejsie.

Wstecz
Create accounts
Dalej
Filter accounts you can access