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 estar 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 devuelven las siguientes cuentas:

  • Todas las cuentas que tienen 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 búsqueda. Encierra entre paréntesis los criterios de filtro a cada lado del operador OR. 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(...).

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

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

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 cómo filtrar cuentas con el método account.list:

"* Todas las cuentas secundarias de MCA que contengan "Store"

accountName = "*store*" AND relationship(service(type = "ACCOUNT_AGGREGATION"))
  • Todas las cuentas que administra 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 método google.shopping.merchant.accounts.v1.ListAccountsRequest, 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 del filtro de AIP y su gramática EBNF formal:

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
    : " = " | " != "
    ;