Sintaxis de filtro

En esta página, se explica la sintaxis que debes usar para filtrar cuentas.

Sintaxis

Todos los valores que no sean números enteros deben encerrarse entre comillas dobles ("). Para saber qué valores acepta un campo específico, consulta la documentación de referencia de ese campo.

Puedes usar AND para filtrar varios campos en la misma consulta. También puedes usar AND para combinar varios filtros relationship(...) y service(...). Este es un ejemplo que combina varios filtros relationship(...) y service(...):

(relationship(service(type = "ACCOUNT_MANAGEMENT") AND service(handshakeState = "PENDING"))) OR (accountName = "store" AND relationship(...))

Este ejemplo muestra las siguientes cuentas:

  • Todas las cuentas que tengan una relación de administración de cuentas con otra cuenta y una relación adicional pendiente de aceptación

  • Todas las cuentas con el nombre visible "store" que tengan relaciones con otras cuentas

No puedes usar AND para filtrar varios valores en el mismo campo. Por ejemplo, no puedes usar accountName = "*A*" AND accountName = "*B*".

Puedes usar OR para filtrar dos campos en la misma consulta. Une los criterios de filtro a cada lado del operador OR con paréntesis. Por ejemplo, (accountName = "storeA") OR (accountName = "storeB").

Solo puedes usar OR para combinar dos campos. Por ejemplo, no puedes usar (accountName = "storeA") OR (accountName = "storeB") OR (accountName = "storeC").

No se permiten paréntesis, excepto con los operadores AND y OR, y en invocaciones de funciones, como relationship(...) y service(...).

En el caso de los campos de cadena, como accountName y accountIdAlias, puedes filtrar los valores que contengan una palabra o secuencia de caracteres determinada si encierras la secuencia entre asteriscos (*). Por ejemplo, accountName = "*foo*" muestra todas las cuentas con un accountName que contiene foo, como "storeFoo".

Puedes filtrar los valores que no contienen una secuencia determinada con != y *. Por ejemplo, accountName != "*foo*" muestra todas las cuentas con un accountName que no contiene foo.

Se ignoran los espacios en blanco adicionales. Por ejemplo, foo AND bar es igual que foo AND bar.

Para filtrar las cuentas a las que tiene acceso el usuario que realiza la solicitud, puedes usar el método google.shopping.merchant.accounts.v1beta.ListAccountsRequest, como se muestra en la siguiente muestra.

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1beta.Account;
import com.google.shopping.merchant.accounts.v1beta.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1beta.AccountsServiceClient.ListAccountsPagedResponse;
import com.google.shopping.merchant.accounts.v1beta.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1beta.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

Especificación

Los filtros siguen un subconjunto de la especificación del filtro de AIP y su gramática formal de EBNF:

filter
    : accountFilterDisj
    | accountFilterConj

accountFilterDisj
    : "(" accountFilterConj " OR " accountFilterConj ")"
    ;
accountFilterConj
    : accountFilter {" AND " accountFilter}
    ;

accountFilter
    : accountNameFilter | capabilityFilter | relationshipFn
    ;

accountNameFilter
    : "accountName" comparator value
    ;

capabilityFilter
    : "capabilities:" capabilityValue
    | "-capabilities:" capabilityValue
    | "NOT capabilities:" capabilityValue
    ;
capabilityValue
    : "CAN_UPLOAD_PRODUCTS"
    ;

relationshipFn
    : "relationship(" relationshipConj ")"
    ;
relationshipConj
    : relationshipFilter {" AND " relationshipFilter}
    ;
relationshipFilter
    : "providerId = " numValue
    | "accountIdAlias" comparator value
    | serviceFn
    ;

serviceFn
    : "service(" serviceConj ")"
    ;
serviceConj
    : serviceFilter {" AND " serviceFilter}
    ;
serviceFilter
    : "externalAccountId" comparator value
    | "handshakeState = " handshakeState
    | "type = " serviceType
    ;

handshakeState
    : "PENDING"
    | "APPROVED"
    | "REJECTED"
    ;
serviceType
    : "ACCOUNT_AGGREGATION"
    | "ACCOUNT_MANAGEMENT"
    ;

comparator
    : " = " | " != "
    ;