Questa pagina è stata tradotta dall'API Cloud Translation.

Filtra gli account a cui puoi accedere

Il metodo accounts.list consente di recuperare un elenco di risorse Account a cui l'utente autenticato può accedere. Puoi utilizzare il parametro della query filter per restringere i risultati in base a vari criteri, ad esempio:

Proprietà dell'account
Relazioni con altri account (ad esempio, fornitori in una struttura di account avanzata)
Servizi associati agli account

Questo può essere utile per gestire più account o trovare account aziendali specifici che soddisfano determinate condizioni.

Puoi utilizzare i seguenti campi per filtrare a livello di account:

access: filtra in base al tipo di accesso dell'utente a account. Questo filtro accetta i seguenti valori:
- DIRECT: restituisce solo gli account a cui l'utente ha accesso diretto.
- INDIRECT: restituisce solo gli account a cui l'utente ha accesso indiretto.
- ALL: restituisce tutti gli account a cui l'utente ha accesso (sia diretto che indiretto). Questo è il comportamento predefinito se il filtro non è specificato.
capabilities: filtra in base al capabilities della risorsa account (tieni presente che questo campo non è disponibile nella risorsa stessa). È supportata solo la funzionalità CAN_UPLOAD_PRODUCTS. Questo campo supporta la negazione e utilizza la sintassi della raccolta.
relationship(...): filtra in base al tipo di relazione che l'account ha con un altro account. Puoi includere più filtri relationship(...) in un'unica richiesta.
accountName: filtra in base al accountName della risorsa account.

Per informazioni più dettagliate sulla sintassi dei filtri, consulta la guida Sintassi dei filtri.

Esempi

Gli esempi riportati di seguito spiegano come formulare le query più comuni. Tutti gli esempi seguenti utilizzano il metodo accounts.list. Per saperne di più, consulta la documentazione di riferimento di accounts.list.

Trovare i subaccount di un fornitore specifico

Il metodo accounts.listSubaccounts fornisce un modo diretto per elencare i subaccount. Puoi anche utilizzare le funzionalità di filtro descritte nelle sezioni seguenti. Se gestisci un account avanzato, puoi elencare tutti i relativi subaccount filtrando in base a providerId. Sostituisci PROVIDER_ID con l'ID del tuo account avanzato.

Ad esempio, utilizza relationship(providerId=123) se l'ID del fornitore è 123.

Questo è utile per gestire la struttura dei tuoi account.

GET https://merchantapi.googleapis.com/accounts/v1/accounts?filter=relationship(providerId%20%3D%20PROVIDER_ID)

Una richiesta riuscita restituisce un codice di stato 200 e un corpo della risposta con l'elenco dei subaccount corrispondenti:

{
  "accounts": [
    {
      "name": "accounts/77777",
      "accountId": "77777",
      "accountName": "SubAccount A of Provider",
      "adultContent": false,
      "languageCode": "fr",
      "timeZone": {
        "id": "Europe/Paris"
      }
    },
    {
      "name": "accounts/88888",
      "accountId": "88888",
      "accountName": "SubAccount B of Provider",
      "adultContent": false,
      "languageCode": "de",
      "timeZone": {
        "id": "Europe/Berlin"
      }
    }
  ],
  "nextPageToken": "XYZ123abcDEF..."
}

Trovare gli account che non possono caricare prodotti

Puoi combinare più condizioni di filtro per creare ricerche più specifiche.

Il filtro accountName=*store* AND -capabilities:CAN_UPLOAD_PRODUCTS trova tutti gli account con "store" nel nome che non sono configurati per caricare direttamente i prodotti. Il - prima di capabilities funge da operatore di negazione. Può essere utile per recuperare solo gli account avanzati.

GET https://merchantapi.googleapis.com/accounts/v1/accounts?filter=accountName%20%3D%20%22*store*%22%20AND%20-capabilities%3ACAN_UPLOAD_PRODUCTS

Una richiesta riuscita restituisce un codice di stato 200 e un corpo della risposta con l'elenco degli account corrispondenti:

{
  "accounts": [
    {
      "name": "accounts/54321",
      "accountId": "54321",
      "accountName": "Partner Store - US",
      "adultContent": false,
      "languageCode": "en",
      "timeZone": {
        "id": "America/New_York"
      }
    },
    {
      "name": "accounts/98765",
      "accountId": "98765",
      "accountName": "Auxiliary Brand Store",
      "adultContent": false,
      "languageCode": "fr",
      "timeZone": {
        "id": "Europe/Paris"
      }
    }
  ],
  "nextPageToken": "CDEfghIJKlmnOPQ..."
}

Trovare gli account in base al nome

Puoi cercare gli account il cui nome visualizzato corrisponde a un pattern specifico.

Ad esempio, accountName=*store* troverebbe tutti gli account con "store" nel nome.

Ciò consente di individuare rapidamente account aziendali specifici.

GET https://merchantapi.googleapis.com/accounts/v1/accounts?filter=accountName%20%3D%20%22*store*%22

Una richiesta riuscita restituisce un codice di stato 200 e un corpo della risposta con l'elenco degli account corrispondenti:

{
  "accounts": [
    {
      "name": "accounts/12345",
      "accountId": "12345",
      "accountName": "My Awesome Store",
      "adultContent": false,
      "languageCode": "en",
      "timeZone": {
        "id": "America/Los_Angeles"
      }
    },
    {
      "name": "accounts/67890",
      "accountId": "67890",
      "accountName": "Another Store Online",
      "adultContent": false,
      "languageCode": "en",
      "timeZone": {
        "id": "Europe/London"
      }
    }
  ],
  "nextPageToken": "ABSdefGHIjklMNO..."
}

Trovare gli account collegati a un fornitore per un servizio specifico

Puoi trovare gli account che hanno una relazione di servizio specifica con un fornitore. Ad esempio, per trovare tutti gli account aggregati nel provider PROVIDER_ID per l'aggregazione degli account, utilizza il filtro relationship(providerId=PROVIDER_ID) AND service(type="ACCOUNT_AGGREGATION").

GET https://merchantapi.googleapis.com/accounts/v1/accounts?filter=relationship(providerId%20%3D%20PROVIDER_ID%20AND%20service(type%20%3D%20%22ACCOUNT_AGGREGATION%22))

Una richiesta riuscita restituisce un codice di stato 200 e un corpo della risposta con l'elenco degli account corrispondenti:

{
  "accounts": [
    {
      "name": "accounts/54321",
      "accountId": "54321",
      "accountName": "Aggregated Account X",
      "adultContent": false,
      "languageCode": "en",
      "timeZone": {
        "id": "America/New_York"
      }
    }
  ]
}

Trovare account in base allo stato di approvazione della relazione di servizio

Puoi filtrare gli account in base allo stato del rapporto di servizio con un fornitore. Ad esempio, per trovare tutti gli account che non hanno accettato una richiesta di collegamento dell'account (handshakeState = "PENDING") da un fornitore specifico PROVIDER_ID.

Ad esempio, per trovare gli account in cui l'ID fornitore è 123, il tipo di servizio è ACCOUNT_MANAGEMENT e lo stato è PENDING, utilizza relationship(service(handshakeState = "PENDING" AND type = "ACCOUNT_MANAGEMENT") AND providerId = 123).

GET https://merchantapi.googleapis.com/accounts/v1/accounts?filter=relationship(service(handshakeState%20%3D%20%22PENDING%22%20AND%20type%20%3D%20%22ACCOUNT_MANAGEMENT%22)%20AND%20providerId%20%3D%20PROVIDER_ID)

Una richiesta riuscita restituisce un codice di stato 200 e un corpo della risposta con l'elenco degli account corrispondenti:

{
  "accounts": [
    {
      "name": "accounts/98765",
      "accountId": "98765",
      "accountName": "Managed Account Y",
      "adultContent": false,
      "languageCode": "es",
      "timeZone": {
        "id": "Europe/Madrid"
      }
    }
  ]
}

Filtrare gli account utilizzando le librerie client

Gli esempi seguenti mostrano come utilizzare le librerie client per filtrare gli account in base a criteri combinati, come il nome dell'account e la relazione con un fornitore. Questi esempi utilizzano il metodo accounts.list. Per saperne di più, consulta la documentazione di riferimento di accounts.list.

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

/** This class demonstrates how to filter the accounts the user making the request has access to. */
public class FilterAccountsSample {

  public static void filterAccounts(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();

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

      // Filter for accounts with display names containing "store" and a provider with the ID "123":
      String filter = "accountName = \"*store*\" AND relationship(providerId = 123)";

      // Filter for all subaccounts of account "123":
      // String filter2 = "relationship(providerId = 123 AND service(type =
      // \"ACCOUNT_AGGREGATION\"))";

      // String filter3 = "relationship(service(handshakeState = \"APPROVED\" AND type =
      // \"ACCOUNT_MANAGEMENT\") AND providerId = 123)";

      ListAccountsRequest request = ListAccountsRequest.newBuilder().setFilter(filter).build();

      System.out.println("Sending list accounts request with filter:");
      ListAccountsPagedResponse response = accountsServiceClient.listAccounts(request);

      int count = 0;

      // Iterates over all rows in all pages and prints the sub-account
      // in each row.
      // `response.iterateAll()` automatically uses the `nextPageToken` and recalls the
      // request to fetch all pages of data.
      for (Account account : response.iterateAll()) {
        System.out.println(account);
        count++;
      }
      System.out.print("The following count of elements were returned: ");
      System.out.println(count);
    } catch (Exception e) {
      System.out.println(e);
    }
  }

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

    filterAccounts(config);
  }
}FilterAccountsSample.java

PHP

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

/**
 * This class demonstrates how to filter the accounts the user making the request has access to.
 */
class FilterAccounts
{
    public static function filterAccounts(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);

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

            // Filter for accounts with display names containing "store" and a provider with the ID "123":
            $filter = "accountName = \"*store*\" AND relationship(providerId = 123)";

            // Filter for all subaccounts of account "123":
            // $filter = "relationship(providerId = 123 AND service(type = \"ACCOUNT_AGGREGATION\"))";

            // $filter = "relationship(service(handshakeState = \"APPROVED\" AND type =
            // \"ACCOUNT_MANAGEMENT\") AND providerId = 123)";

            $request = new ListAccountsRequest(['filter' => $filter]);

            print "Sending list accounts request with filter:\n";
            $response = $accountsServiceClient->listAccounts($request);

            $count = 0;

            // Iterates over all rows in all pages and prints the sub-account
            // in each row.
            // `response.iterateAll()` automatically uses the `nextPageToken` and recalls the
            // request to fetch all pages of data.
            foreach ($response->iterateAllElements() as $account) {
                print_r($account); 
                $count++;
            }
            print "The following count of elements were returned: ";
            print $count . PHP_EOL;
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }

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

$sample = new FilterAccounts();
$sample->callSample();FilterAccountsSample.php

Python

from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AccountsServiceClient
from google.shopping.merchant_accounts_v1 import ListAccountsRequest


def filter_accounts():
  """Filters the accounts the user making the request has access to."""

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

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

  # Create the filter string.
  filter_string = 'accountName = "*store*" AND relationship(providerId = 123)'

  # Create the request.
  request = ListAccountsRequest(filter=filter_string)

  # Make the request and print the response.
  try:
    print("Sending list accounts request with filter:")
    response = client.list_accounts(request=request)

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

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

  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  filter_accounts()
filter_accounts_sample.py

AppsScript


/**
 * Filters and lists accounts for which the logged-in user has access to
 */
function filterAccounts() {
  // IMPORTANT:
  // Enable the Merchant API Accounts sub-API Advanced Service and call it
  // "MerchantApiAccounts"

  // Create the filter string.
  // Documentation can be found at
  // https://developers.google.com/merchant/api/guides/accounts/filter-syntax
  const filter = 'accountName = "*store*" AND relationship(providerId = 123)';
  try {
    console.log('Sending filter Accounts request');
    let pageToken;
    let pageSize = 500;
    // Call the Accounts.list API method with a filter. Use the pageToken to iterate through
    // all pages of results.
    do {
      response =
          MerchantApiAccounts.Accounts.list({pageSize, pageToken, filter});
      for (const account of response.accounts) {
        console.log(account);
      }
      pageToken = response.nextPageToken;
    } while (pageToken);  // Exits when there is no next page token.

  } catch (e) {
    console.log('ERROR!');
    console.log(e);
  }
}filter_accounts_sample.gs

cURL

curl --location 'https://merchantapi.googleapis.com/accounts/v1/accounts?filter=accountName%20%3D%20%22*store*%22%20AND%20relationship(providerId%20%3D%20PROVIDER_ID)' \
--header 'Authorization: Bearer <API_TOKEN>'

Indietro

Create and manage sub-accounts

Avanti

Control access to your account