จัดการข้อตกลงเกี่ยวกับข้อกำหนดในการให้บริการของ Merchant Center

หากต้องการใช้ Merchant Center และฟีเจอร์ต่างๆ คุณต้องยอมรับข้อกำหนดในการให้บริการ (ToS) ของ Merchant Center สำหรับสถานที่ตั้งธุรกิจของคุณ ข้อตกลงเหล่านี้ระบุข้อกำหนดทางกฎหมายสำหรับการใช้บริการ Merchant Center

คู่มือนี้อธิบายวิธีใช้ Merchant API เพื่อจัดการข้อตกลงเหล่านี้ ไม่ว่าจะเป็นบัญชีของคุณเองหรือบัญชีที่คุณจัดการในฐานะผู้ให้บริการบุคคลที่สาม (3P)

คุณจะทำสิ่งต่อไปนี้ได้

  • ตรวจสอบสถานะข้อตกลงตามข้อกำหนดในการให้บริการปัจจุบันของบัญชี
  • แนะนําให้ผู้ขายยอมรับข้อกำหนดในการให้บริการที่จำเป็น
  • จัดการข้อกำหนดในการให้บริการในฐานะผู้ให้บริการบุคคลที่สามสำหรับบัญชีลูกค้าหรือบัญชีแบบสแตนด์อโลน

ข้อกำหนดเบื้องต้น

หากต้องการใช้ Merchant API คุณต้องมีบัญชี Merchant Center เมื่อสร้างบัญชีโดยใช้อินเทอร์เฟซผู้ใช้ (UI) ของ Merchant Center แล้ว คุณจะทำการเปลี่ยนแปลงบัญชีได้ (เช่น อัปเดตข้อมูลทางธุรกิจ จัดการผู้ใช้ ฯลฯ) โดยใช้ UI หรือ API

หากต้องการจัดการหลายบัญชี คุณสามารถสร้างบัญชีลูกค้าได้โดยใช้ Merchant API ดูสร้างและจัดการบัญชีย่อย

ตรวจสอบสถานะการยอมรับข้อกำหนดในการให้บริการของบัญชี

ก่อนที่ผู้ขายจะใช้ Merchant Center ได้อย่างเต็มที่ หรือหากคุณต้องการยืนยันสถานะข้อตกลงปัจจุบันของผู้ขาย คุณสามารถดึงสถานะข้อตกลงในข้อกำหนดในการให้บริการของผู้ขายได้

ใช้เมธอด termsOfServiceAgreementStates.retrieveForApplication เพื่อรับสถานะข้อตกลงในข้อกำหนดในการให้บริการสำหรับแอปพลิเคชันหลักของ Merchant Center เมธอดนี้จะแสดงข้อกำหนดในการให้บริการปัจจุบัน (หากมี) และหากมีการอัปเดตข้อกำหนดในการให้บริการ นับตั้งแต่ที่คุณยอมรับครั้งล่าสุด ก็จะแสดงเวอร์ชันล่าสุดที่คุณต้องยอมรับ

ตัวอย่างคำขอมีดังนี้

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

การเรียกที่สำเร็จจะแสดงผลทรัพยากร TermsOfServiceAgreementState แหล่งข้อมูลนี้มีข้อมูลต่อไปนี้

  • name: ตัวระบุสำหรับสถานะข้อตกลงนี้
  • regionCode: ประเทศที่สถานะข้อตกลงนี้มีผลบังคับใช้ ซึ่งโดยปกติแล้วจะเป็น ประเทศที่ตั้งธุรกิจของบัญชี
  • termsOfServiceKind: ซึ่งจะเป็น MERCHANT_CENTER
  • accepted: รายละเอียดเกี่ยวกับข้อกำหนดในการให้บริการเวอร์ชันที่บัญชีได้ยอมรับแล้ว รวมถึงtermsOfServiceชื่อทรัพยากร (เช่น termsOfService/132) และผู้ที่acceptedBy นอกจากนี้ อาจมีvalidUntilวันที่หากมีการrequiredข้อกำหนดในการให้บริการเวอร์ชันใหม่
  • required: รายละเอียดเกี่ยวกับข้อกำหนดในการให้บริการเวอร์ชันที่บัญชีต้องยอมรับ ซึ่งรวมถึงtermsOfServiceชื่อทรัพยากรและtosFileUriที่ชี้ไปยัง เอกสารข้อกำหนดในการให้บริการที่มนุษย์อ่านได้

ตัวอย่างคำตอบ:

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

หากมีข้อกำหนดในการให้บริการใหม่required คุณควรแนะนำให้ผู้ขายยอมรับข้อกำหนดดังกล่าว

นี่คือตัวอย่างที่คุณใช้เพื่อดึงข้อมูลสถานะข้อตกลงเกี่ยวกับข้อกำหนดในการให้บริการสำหรับ บัญชีและประเทศที่เฉพาะเจาะจงได้

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1beta.GetTermsOfServiceAgreementStateRequest;
import com.google.shopping.merchant.accounts.v1beta.TermsOfServiceAgreementState;
import com.google.shopping.merchant.accounts.v1beta.TermsOfServiceAgreementStateName;
import com.google.shopping.merchant.accounts.v1beta.TermsOfServiceAgreementStateServiceClient;
import com.google.shopping.merchant.accounts.v1beta.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\V1beta\Client\TermsOfServiceAgreementStateServiceClient;
use Google\Shopping\Merchant\Accounts\V1beta\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_v1beta import GetTermsOfServiceAgreementStateRequest
from google.shopping.merchant_accounts_v1beta 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

ยอมรับข้อกำหนดในการให้บริการ

ผู้ขายต้องยอมรับข้อกำหนดในการให้บริการล่าสุดเพื่อคงสิทธิ์เข้าถึงฟีเจอร์ของ Merchant Center

ยอมรับข้อกำหนดในการให้บริการสำหรับบัญชีของคุณเอง

หากคุณจัดการบัญชี Merchant Center ของตนเอง ให้ทำดังนี้

  1. โทรหา termsOfServiceAgreementStates.retrieveForApplication เพื่อตรวจสอบว่าข้อกำหนดในการให้บริการใดrequired
  2. หากต้องมีข้อกำหนดในการให้บริการ ให้จดtermsOfServiceชื่อจากrequired ฟิลด์ (เช่น termsOfService/132)

  3. โทรหา termsOfService.accept เพื่อยอมรับข้อกำหนดในการให้บริการ คุณจะต้องมีชื่อ ToS, ACCOUNT_ID และ regionCode ที่ได้จาก retrieveForApplication

    ตัวอย่างคำขอมีดังนี้

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

    การเรียกที่สำเร็จจะแสดงเนื้อหาการตอบกลับที่ว่างเปล่า และอัปเดตสถานะการยอมรับข้อกำหนดในการให้บริการของบัญชี

แนะนําผู้ขายให้ยอมรับข้อกำหนดในการให้บริการ (สําหรับผู้ให้บริการบุคคลที่สาม)

หากคุณเป็นผู้ให้บริการบุคคลที่สาม (3P) ที่จัดการบัญชี Merchant Center แบบสแตนด์อโลนสำหรับธุรกิจอื่นๆ คุณต้องไม่ยอมรับข้อกำหนดในการให้บริการในนามของธุรกิจเหล่านั้น แต่คุณควรทำดังนี้แทน

  1. ดึงข้อมูลข้อกำหนดในการให้บริการล่าสุด: เรียกใช้ termsOfService.retrieveLatest สำหรับ regionCode และ MERCHANT_CENTER ของผู้ขายเพื่อดู รายละเอียดของข้อกำหนดในการให้บริการเวอร์ชันล่าสุดที่ผู้ขายอาจต้องยอมรับ

    ตัวอย่างคำขอ

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

    ตัวอย่างการตอบกลับ

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

  2. แสดงข้อกำหนดในการให้บริการ: ใช้ fileUri จากการตอบกลับเพื่อแสดงข้อความฉบับเต็มของข้อกำหนดในการให้บริการแก่ผู้ขายภายใน UI ของแอปพลิเคชัน

  3. ได้รับการยอมรับจากผู้ขาย: ผู้ขายต้องยอมรับข้อกำหนดอย่างชัดแจ้งภายใน UI ของคุณ

  4. บันทึกการยอมรับโดยใช้ API: หลังจากผู้ขายยอมรับ ให้เรียกใช้ termsOfService.accept โดยใช้ name ของข้อกำหนดในการให้บริการที่ได้รับในขั้นตอนที่ 1, ACCOUNT_ID ของผู้ขาย และ regionCode ของผู้ขาย

    ตัวอย่างคำขอ

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

ต่อไปนี้คือตัวอย่างที่คุณใช้เพื่อยอมรับข้อตกลงเกี่ยวกับข้อกำหนดในการให้บริการสำหรับบัญชีหนึ่งๆ ได้ (หลังจากที่ผู้ขายยอมรับแล้ว)

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1beta.AcceptTermsOfServiceRequest;
import com.google.shopping.merchant.accounts.v1beta.TermsOfServiceServiceClient;
import com.google.shopping.merchant.accounts.v1beta.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\V1beta\AcceptTermsOfServiceRequest;
use Google\Shopping\Merchant\Accounts\V1beta\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_v1beta import AcceptTermsOfServiceRequest
from google.shopping.merchant_accounts_v1beta 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

ข้อควรพิจารณาเป็นพิเศษสำหรับผู้ให้บริการบุคคลที่สาม

ในฐานะผู้ให้บริการบุคคลที่สาม คุณอาจจัดการข้อกำหนดในการให้บริการสำหรับบัญชีลูกค้าหรือบัญชีแบบสแตนด์อโลน

จัดการข้อกำหนดในการให้บริการสำหรับบัญชีลูกค้า

หากคุณใช้งานบัญชีขั้นสูง และสร้าง บัญชีลูกค้าสำหรับธุรกิจต่างๆ ให้ทำดังนี้

  • การยอมรับบัญชีขั้นสูง: หากบัญชีขั้นสูงให้บริการรวบรวมข้อมูลบัญชีแก่บัญชีลูกค้า ข้อกำหนดในการให้บริการที่บัญชีขั้นสูงยอมรับจะมีผลกับบัญชีลูกค้าทั้งหมดที่ใช้บริการนั้นด้วย
  • การแสดงและการขอความยินยอม: แม้ว่าการยอมรับของบัญชีขั้นสูงจะครอบคลุมบัญชีลูกค้า แต่แนวทางปฏิบัติแนะนำ (และอาจเป็นข้อกำหนดทางกฎหมาย) คือการแสดงข้อกำหนดในการให้บริการของ Google Merchant Center ที่เกี่ยวข้องต่อเจ้าของธุรกิจจริงของบัญชีลูกค้าแต่ละบัญชี คุณต้องได้รับความยินยอมอย่างชัดแจ้งจากผู้ใช้ว่าผู้ใช้เข้าใจและยอมรับข้อกำหนดเหล่านี้ แม้ว่าจะมีการเรียก API เพื่อยอมรับที่ระดับบัญชีขั้นสูงก็ตาม
  • การตรวจสอบสถานะบัญชีลูกค้า: ใช้ termsOfServiceAgreementStates.retrieveForApplication ในบัญชีลูกค้าที่เฉพาะเจาะจงเพื่อยืนยันสถานะข้อกำหนดในการให้บริการและดูว่าบัญชี อยู่ภายใต้ข้อตกลงของบัญชีขั้นสูงหรือไม่ หรือต้องดำเนินการโดยตรง หรือไม่

จัดการข้อกำหนดในการให้บริการสำหรับบัญชีแบบสแตนด์อโลน

ตามที่ระบุไว้ในแนะนําให้ผู้ขายยอมรับ ข้อกําหนดในการให้บริการ เมื่อคุณช่วยเหลือ ธุรกิจในการสร้างหรือจัดการบัญชี Merchant Center แบบสแตนด์อโลน ธุรกิจดังกล่าว (เจ้าของบัญชี) ต้องยอมรับข้อกำหนดในการให้บริการด้วยตนเอง คุณอำนวยความสะดวกในเรื่องนี้ได้โดยการดึงและแสดงข้อกำหนดในการให้บริการ แล้วเรียกใช้เมธอด termsOfService.accept ในนามของผู้ใช้หลังจากที่ผู้ใช้ให้ความยินยอมอย่างชัดแจ้งผ่านอินเทอร์เฟซของคุณ

ก่อนหน้า
Overview
ถัดไป
Create and manage sub-accounts