Sintaxis de filtro

En algunos métodos list de la API de Merchant, como account.list puedes realizar un filtrado para obtener solo los resultados que te interesan. Para filtrar los resultados, usa el parámetro filter con la sintaxis definida en la gramática EBNF. En esta página, se explica cómo usar la sintaxis para filtrar cuentas.

Sintaxis

Todos los valores que no sean números enteros deben incluirse 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(...))

En este ejemplo, se muestran las siguientes cuentas:

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

• Todas las cuentas con el nombre visible "store" que tienen 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. Incluye los criterios de filtro en cada lado del operador OR entre 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 las invocaciones de funciones, como relationship(...) y service(...).

Para los campos de cadena como accountName y accountIdAlias, puedes filtrar los valores que contienen una palabra o secuencia de caracteres determinada. Para ello, incluye la secuencia entre asteriscos (*). Por ejemplo, accountName = "*foo*" muestra todas las cuentas con un accountName que contiene foo, como "storeFoo".

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

Nota: El filtrado por accountIdAlias o externalAccountId solo es posible si también se establece un providerId como estos campos. El uso de estos campos solo tiene sentido en el contexto de un providerId específico.

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

A continuación, se muestran algunos ejemplos de filtrado de cuentas con el account.list:

• Todas las subcuentas de una cuenta avanzada que contengan "Store":

accountName = "*store*" AND relationship(service(type = "ACCOUNT_AGGREGATION"))

• Todas las cuentas administradas por el proveedor 123456:

relationship(service(type = "ACCOUNT_MANAGEMENT") AND providerId = 123456)

• Todas las cuentas que enviaron una invitación al proveedor 123456 o que deben aceptar una invitación de este proveedor:

relationship(service(handshakeState = "PENDING" AND type ="ACCOUNT_MANAGEMENT")
AND providerId = 123456)

Para filtrar las cuentas a las que puede acceder el usuario que realiza la solicitud, usa el google.shopping.merchant.accounts.v1.ListAccountsRequest método, como se muestra en el siguiente ejemplo.

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

Especificación

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

filter
    : accountFilterDisj
    | accountFilterConj

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

accountFilter
    : accountNameFilter | capabilityFilter | relationshipFn | accessFilter
    ;

accountNameFilter
    : "accountName" comparator value
    ;

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

accessFilter
    : "access = " accessType
    ;

accessType
    : "DIRECT"
    | "INDIRECT"
    | "ALL"
    ;

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"
    | "WAITING"
    | "ESTABLISHED"
    | "REJECTED"
    ;
serviceType
    : "ACCOUNT_AGGREGATION"
    | "ACCOUNT_MANAGEMENT"
    ;

comparator
    : " = "
    | " != "
    ;