Configuration d'un compte d'émetteur

Conditions préalables

Assurez-vous d'effectuer les étapes suivantes avant de continuer :

• Conditions préalables

Déterminer le compte à activer pour Smart Tap

Avant de continuer, vous devez identifier le compte qui sera désigné comme compte d'émetteur d'offres. Pour cela, vous pouvez procéder de deux façons :

Créer un compte d'émetteur

Les coordonnées du nouveau compte doivent inclure celles du marchand. Pour savoir comment créer un compte d'émetteur dans la Google Pay & Wallet Console, consultez cet article d'aide. L'exemple de code suivant montre comment procéder avec l'API Google Wallet :

Java

/**
 * Create a new Google Wallet Issuer account.
 *
 * @param issuerName The Issuer's name.
 * @param issuerEmail The Issuer's email address.
 * @throws IOException
 */
public void CreateIssuerAccount(String issuerName, String issuerEmail) throws IOException {
  // New Issuer information
  Issuer issuer =
      new Issuer()
          .setName(issuerName)
          .setContactInfo(new IssuerContactInfo().setEmail(issuerEmail));

  Issuer response = service.issuer().insert(issuer).execute();

  System.out.println("Issuer insert response");
  System.out.println(response.toPrettyString());
}

PHP

/**
 * Create a new Google Wallet issuer account.
 *
 * @param string $issuerName The Issuer's name.
 * @param string $issuerEmail The Issuer's email address.
 */
public function createIssuerAccount(string $issuerName, string $issuerEmail)
{
  // New Issuer information
  $issuer = new Google_Service_Walletobjects_Issuer([
    'name' => $issuerName,
    'contactInfo' => new Google_Service_Walletobjects_IssuerContactInfo([
      'email' => $issuerEmail,
    ]),
  ]);

  $response = $this->service->issuer->insert($issuer);

  print "Issuer insert response\n";
  print_r($response);
}

Python

def create_issuer_account(self, issuer_name: str, issuer_email: str):
    """Create a new Google Wallet Issuer account.

    Args:
        issuer_name (str): The Issuer's name.
        issuer_email (str): The Issuer's email address.
    """
    # New Issuer information
    issuer = {'name': issuer_name, 'contactInfo': {'email': issuer_email}}

    # Make the POST request
    response = self.http_client.post(url=self.issuer_url, json=issuer)

    print('Issuer insert response')
    print(response.text)

C#

/// <summary>
/// Create a new Google Wallet Issuer account.
/// </summary>
/// <param name="issuerName">The Issuer's name.</param>
/// <param name="issuerEmail">The Issuer's email address.</param>
public void CreateIssuerAccount(string issuerName, string issuerEmail)
{
  // New issuer information
  Issuer issuer = new Issuer()
  {
    ContactInfo = new IssuerContactInfo()
    {
      Email = issuerEmail
    },
    Name = issuerName,
  };

  Stream responseStream = service.Issuer
      .Insert(issuer)
      .ExecuteAsStream();
  StreamReader responseReader = new StreamReader(responseStream);
  JObject jsonResponse = JObject.Parse(responseReader.ReadToEnd());

  Console.WriteLine("Issuer insert response");
  Console.WriteLine(jsonResponse.ToString());
}

Node.js

/**
 * Create a new Google Wallet Issuer account.
 *
 * @param {string} issuerName The Issuer's name.
 * @param {string} issuerEmail The Issuer's email address.
 */
async createIssuerAccount(issuerName, issuerEmail) {
  // New Issuer information
  let issuer = {
    name: issuerName,
    contactInfo: {
      email: issuerEmail
    }
  };

  let response = await this.httpClient.request({
    url: this.issuerUrl,
    method: 'POST',
    data: issuer
  });

  console.log('Issuer insert response');
  console.log(response);
}

Au départ, seul le compte principal (compte de service ou utilisateur) qui a créé le compte d'émetteur y a accès. Vous devez mettre à jour les autorisations du compte d'émetteur pour inclure tous les utilisateurs ou comptes de service supplémentaires qui doivent pouvoir gérer les cartes. L'exemple de code suivant montre comment mettre à jour les autorisations du compte d'émetteur.

Java

/**
 * Update permissions for an existing Google Wallet Issuer account.
 *
 * <p><strong>Warning:</strong> This operation overwrites all existing permissions!
 *
 * <p>Example permissions list argument below. Copy the add entry as needed for each email address
 * that will need access. Supported values for role are: 'READER', 'WRITER', and 'OWNER'
 *
 * <pre><code>
 * ArrayList<Permission> permissions = new ArrayList<Permission>();
 * permissions.add(new Permission().setEmailAddress("emailAddress").setRole("OWNER"));
 * </code></pre>
 *
 * @param issuerId The Issuer ID being used for this request.
 * @param permissions The list of email addresses and roles to assign.
 * @throws IOException
 */
public void UpdateIssuerAccountPermissions(String issuerId, ArrayList<Permission> permissions)
    throws IOException {

  Permissions response =
      service
          .permissions()
          .update(
              Long.parseLong(issuerId),
              new Permissions().setIssuerId(Long.parseLong(issuerId)).setPermissions(permissions))
          .execute();

  System.out.println("Issuer permissions update response");
  System.out.println(response.toPrettyString());
}

PHP

/**
 * Update permissions for an existing Google Wallet Issuer account.
 *
 * **Warning:** This operation overwrites all existing permissions!
 *
 * Example permissions list argument below. Copy the entry as
 * needed for each email address that will need access. Supported
 * values for role are: 'READER', 'WRITER', and 'OWNER'
 *
 * $permissions = array(
 *  new Google_Service_Walletobjects_Permission([
 *    'emailAddress' => 'email-address',
 *    'role' => 'OWNER',
 *  ]),
 * );
 *
 * @param string $issuerId The Issuer ID being used for this request.
 * @param array $permissions The list of email addresses and roles to assign.
 */
public function updateIssuerAccountPermissions(string $issuerId, array $permissions)
{
  // Make the PUT request
  $response = $this->service->permissions->update(
    $issuerId,
    new Google_Service_Walletobjects_Permissions([
      'issuerId' => $issuerId,
      'permissions' => $permissions,
    ])
  );

  print "Permissions update response\n";
  print_r($response);
}

Python

def update_issuer_account_permissions(self, issuer_id: str,
                                      permissions: List):
    """Update permissions for an existing Google Wallet Issuer account.

    **Warning:** This operation overwrites all existing permissions!

    Example permissions list argument below. Copy the dict entry as
    needed for each email address that will need access. Supported
    values for role are: 'READER', 'WRITER', and 'OWNER'

    permissions = [
        {
            'emailAddress': 'email-address',
            'role': 'OWNER'
        }
    ]

    Args:
        issuer_id (str): The Issuer ID being used for this request.
        permissions (List): The list of email addresses and roles to assign.
    """
    response = self.http_client.put(url=f'{self.permissions_url}/{issuer_id}',
                                    json={
                                        'issuerId': issuer_id,
                                        'permissions': permissions
                                    })

    print('Permissions update response')
    print(response.text)

C#

/// <summary>
/// Update permissions for an existing Google Wallet Issuer account.
/// <para />
/// <strong>Warning:</strong> This operation overwrites all existing permissions!
/// <para />
/// Example permissions list argument below. Copy the add entry as needed for each email
/// address that will need access.Supported values for role are: 'READER', 'WRITER', and 'OWNER'
/// <para />
/// <![CDATA[List&lt;Permission> permissions = new List&lt;Permission>();]]>
/// <para />
/// permissions.Add(new Permission { EmailAddress = "emailAddress", Role = "OWNER"});
/// </summary>
/// <param name="issuerId">The issuer ID being used for this request.</param>
/// <param name="permissions">The list of email addresses and roles to assign.</param>
public void UpdateIssuerAccountPermissions(string issuerId, List<Permission> permissions)
{
  Stream responseStream = service.Permissions
      .Update(new Permissions
      {
        IssuerId = long.Parse(issuerId),
        PermissionsValue = permissions
      },
      long.Parse(issuerId))
      .ExecuteAsStream();
  StreamReader responseReader = new StreamReader(responseStream);
  JObject jsonResponse = JObject.Parse(responseReader.ReadToEnd());

  Console.WriteLine("Issuer permissions update response");
  Console.WriteLine(jsonResponse.ToString());
}

Node.js

/**
 * Update permissions for an existing Google Wallet Issuer account.
 *
 * **Warning:** This operation overwrites all existing permissions!
 *
 * Example permissions list argument below. Copy the dict entry as
 * needed for each email address that will need access. Supported
 * values for role are: 'READER', 'WRITER', and 'OWNER'
 *
 * let permissions = [
 *  {
 *    'emailAddress': 'email-address',
 *    'role': 'OWNER',
 *  },
 * ];
 *
 * @param {string} issuerId The Issuer ID being used for this request.
 * @param {Array} permissions The list of email addresses and roles to assign.
 */
async updateIssuerPermissions(issuerId, permissions) {
  let response = await this.httpClient.request({
    url: `${this.permissionsUrl}/${issuerId}`,
    method: 'PUT',
    data: {
      issuerId: issuerId,
      permissions: permissions
    }
  });

  console.log('Permissions update response');
  console.log(response);
}

Utiliser un compte existant

Vous devez prendre en compte les critères suivants pour déterminer si vous pouvez utiliser un compte d'émetteur contenant des classes de carte existantes.

• Si le compte d'émetteur pour le développement de cartes contient des classes correspondant à d'autres marchands, vous devez configurer un nouveau compte au nom du marchand.
• Si votre compte d'émetteur pour le développement de cartes ne contient que des classes correspondant à ce marchand spécifique, vous pouvez l'utiliser.

Si le compte répond à ces critères, vous devez mettre à jour les coordonnées dans la fiche d'établissement avec celles du marchand afin de vous assurer que le nom du compte permet de l'identifier. Personne d'autre que vous ne doit disposer d'un accès API à ce compte. Les autres développeurs de cartes doivent créer leurs propres comptes d'émetteur.

Configuration d'un compte d'émetteur d'offres

Utiliser la Google Pay & Wallet Console

Dans le compte d'émetteur d'offres, procédez comme suit :

1. Accédez à la section API Google Wallet.
2. Sélectionnez Autres fonctionnalités.
3. Sélectionnez Ajouter une clé d'authentification.
4. Importez une clé publique (fichier .pem) et spécifiez une version de clé.
5. Sélectionnez Créer la clé d'authentification.

Vous obtiendrez l'ID de marchand une fois la clé d'authentification importée.

Remarque : Si votre fournisseur de terminaux ne vous procure pas de clé publique tant que vous n'avez pas indiqué d'ID de marchand, vous pouvez en générer une à l'aide de la clé de démonstration ci-dessous. Veillez à supprimer cette clé de démonstration après avoir obtenu de votre fournisseur de terminaux la clé publique officielle.

-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEchyXj869zfmKhRi9xP7f2AK07kEo
4lE7ZlWTN14jh4YBTny+hRGRXcUzevV9zSSPJlPHpqqu5pEwlv1xyFvE1w==
-----END PUBLIC KEY-----

Utiliser l'API Google Wallet

Importer une clé publique

Pour attribuer des clés publiques et des versions de clé à l'aide de l'API Google Wallet, vous devez envoyer une requête PATCH au point de terminaison des émetteurs.

PATCH https://walletobjects.googleapis.com/walletobjects/v1/issuer/{issuerId}

Important : La propriété smartTapMerchantData.authenticationKeys[].id doit être un entier compris entre 1 et 2,147,483,647 (inclus). Chaque clé publique doit posséder une version de clé unique.

Le corps de la requête PATCH se présente comme suit :

{
    "smartTapMerchantData": {
        "authenticationKeys": [
            {
                "id": 1,
                "publicKeyPem": "-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----"
            },
            {
                "id": 2,
                "publicKeyPem": "-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----"
            }
        ]
    }
}

L'exemple de code suivant montre comment mettre à jour un compte d'émetteur pour inclure la clé publique de démonstration mentionnée précédemment :

Java

/**
 * Add a new public key to an Issuer account.
 *
 * @param issuerId The issuer ID being used for this request.
 * @throws IOException
 */
public void AddSmartTapKey(Long issuerId) throws IOException {
  // New smart tap key information
  Issuer patchBody =
      new Issuer()
          .setSmartTapMerchantData(
              new SmartTapMerchantData()
                  .setAuthenticationKeys(
                      Arrays.asList(
                          new AuthenticationKey()
                              .setId(1)
                              .setPublicKeyPem(
                                  "-----BEGIN PUBLIC KEY-----\n"
                                      + "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEchyXj869zfmKhRi9xP7f2AK07kEo\n"
                                      + "4lE7ZlWTN14jh4YBTny+hRGRXcUzevV9zSSPJlPHpqqu5pEwlv1xyFvE1w==\n"
                                      + "-----END PUBLIC KEY-----"))));

  Issuer response = service.issuer().patch(issuerId, patchBody).execute();

  System.out.println("Issuer patch response");
  System.out.println(response.toPrettyString());
}

PHP

/**
 * Add a new public key to an Issuer account.
 *
 * @param string $issuerId The issuer ID being used for this request.
 */
public function addSmartTapKey(string $issuerId)
{
  // New smart tap key information
  $patchBody = new Google_Service_Walletobjects_Issuer([
    'smartTapMerchantData' => new Google_Service_Walletobjects_SmartTapMerchantData([
      'authenticationKeys' => [
        new Google_Service_Walletobjects_AuthenticationKey([
          'id' => 1,
          'publicKeyPem' => "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEchyXj869zfmKhRi9xP7f2AK07kEo\n4lE7ZlWTN14jh4YBTny+hRGRXcUzevV9zSSPJlPHpqqu5pEwlv1xyFvE1w==\n-----END PUBLIC KEY-----"
        ])
      ]
    ])
  ]);

  $response = $this->service->issuer->patch($issuerId, $patchBody);

  print "Issuer patch response\n";
  print_r($response);
}

Python

def add_smart_tap_key(self, issuer_id: str) -> str:
    """Add a new public key to an Issuer account.

    Args:
        issuer_id (str): The issuer ID being used for this request.
    """
    # New smart tap key information
    patch_body = {
        'smartTapMerchantData': {
            'authenticationKeys': [{
                'id':
                    1,
                'publicKeyPem':
                    '-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEchyXj869zfmKhRi9xP7f2AK07kEo\n4lE7ZlWTN14jh4YBTny+hRGRXcUzevV9zSSPJlPHpqqu5pEwlv1xyFvE1w==\n-----END PUBLIC KEY-----'
            }]
        }
    }

    # Make the PATCH request
    response = self.http_client.patch(url=f'{self.issuer_url}/{issuer_id}', json=patch_body)

    print('Issuer patch response')
    print(response.text)

    return response.json()['smartTapMerchantData']['smartTapMerchantId']

C#

/// <summary>
/// Add a new public key to an Issuer account.
/// </summary>
/// <param name="issuerId">The issuer ID being used for this request.</param>
public void AddSmartTapKey(long issuerId)
{
  // New smart tap key information
  Issuer patchBody = new Issuer()
  {
    SmartTapMerchantData = new SmartTapMerchantData
    {
      AuthenticationKeys = new List<AuthenticationKey>
      {
        new AuthenticationKey
        {
          Id = 1,
          PublicKeyPem = "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEchyXj869zfmKhRi9xP7f2AK07kEo\n4lE7ZlWTN14jh4YBTny+hRGRXcUzevV9zSSPJlPHpqqu5pEwlv1xyFvE1w==\n-----END PUBLIC KEY-----"
        }
      }
    }
  };

  Stream responseStream = service.Issuer
      .Patch(patchBody, issuerId)
      .ExecuteAsStream();
  StreamReader responseReader = new StreamReader(responseStream);
  JObject jsonResponse = JObject.Parse(responseReader.ReadToEnd());

  Console.WriteLine("Issuer patch response");
  Console.WriteLine(jsonResponse.ToString());
}

Node.js

/**
 * Add a new public key to an Issuer account.
 *
 * @param {string} issuerId The issuer ID being used for this request.
 */
async addSmartTapKey(issuerId) {
  // New smart tap key information
  let patchBody = {
    smartTapMerchantData: {
      authenticationKeys: [
        {
          id: 1,
          publicKeyPem: '-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEchyXj869zfmKhRi9xP7f2AK07kEo\n4lE7ZlWTN14jh4YBTny+hRGRXcUzevV9zSSPJlPHpqqu5pEwlv1xyFvE1w==\n-----END PUBLIC KEY-----'
        }
      ]
    }
  };

  let response = await this.httpClient.request({
    url: `${this.issuerUrl}/${issuerId}`,
    method: 'PATCH',
    data: patchBody
  });

  console.log('Issuer patch response');
  console.log(response);
}

La réponse comprend le corps que vous avez envoyé et un champ supplémentaire, smartTapMerchantData.smartTapMerchantId. Il s'agit de l'ID de marchand du compte d'émetteur d'offres.

Obtenir l'ID de marchand

Après avoir ajouté des clés et des versions de clé, vous pouvez utiliser l'API Google Wallet pour obtenir votre ID de marchand. Pour cela, vous devez envoyer une requête GET au point de terminaison des émetteurs.

GET https://walletobjects.googleapis.com/walletobjects/v1/issuer/{issuerId}

Java

/**
 * Get the Collector ID for an Issuer account.
 *
 * @param issuerId The issuer ID being used for this request.
 * @return The Collector ID
 * @throws IOException
 */
public Long GetCollectorId(Long issuerId) throws IOException {
  Issuer response = service.issuer().get(issuerId).execute();

  System.out.println("Issuer patch response");
  System.out.println(response.toPrettyString());

  return response.getSmartTapMerchantData().getSmartTapMerchantId();
}

PHP

/**
 * Get the Collector ID for an Issuer account.
 *
 * @param string $issuerId The issuer ID being used for this request.
 * @return string The Collector ID.
 */
public function getCollectorId(string $issuerId)
{
  $response = $this->service->issuer->get($issuerId);

  print "Issuer get response\n";
  print_r($response);

  return $response['smartTapMerchantData']['smartTapMerchantId'];
}

Python

def get_collector_id(self, issuer_id: str) -> str:
    """Get the Collector ID for an Issuer account.

    Args:
        issuer_id (str): The issuer ID being used for this request.
    """
    # Make the GET request
    response = self.http_client.get(url=f'{self.issuer_url}/{issuer_id}')

    print('Issuer get response')
    print(response.text)

    return response.json()['smartTapMerchantData']['smartTapMerchantId']

C#

/// <summary>
/// Get the Collector ID for an Issuer account.
/// </summary>
/// <param name="issuerId">The issuer ID being used for this request.</param>
/// <returns>The Collector ID</returns>
public string GetCollectorId(long issuerId)
{
  Stream responseStream = service.Issuer
      .Get(issuerId)
      .ExecuteAsStream();
  StreamReader responseReader = new StreamReader(responseStream);
  JObject jsonResponse = JObject.Parse(responseReader.ReadToEnd());

  Console.WriteLine("Issuer get response");
  Console.WriteLine(jsonResponse.ToString());

  return jsonResponse["smartTapMerchantData"]["smartTapMerchantId"].Value<string>();
}

Node.js

/**
 * Get the Collector ID for an Issuer account.
 *
 * @param {string} issuerId The issuer ID being used for this request.
 *
 * @returns {string} The Collector ID
 */
async getCollectorId(issuerId) {
  let response = await this.httpClient.request({
    url: `${this.issuerUrl}/${issuerId}`,
    method: 'GET'
  });

  console.log('Issuer patch response');
  console.log(response);

  return response.data.smartTapMerchantData.smartTapMerchantId;
}

La réponse inclut le champ smartTapMerchantData.smartTapMerchantId. Il s'agit de l'ID de marchand du compte d'émetteur d'offres.

Gestion du compte d'émetteur

Organisation des cartes

Deux approches sont communément adoptées afin de gérer les classes et les objets de carte pour plusieurs marchands :

• Un compte d'émetteur central pour tous les marchands
• Un nouveau compte d'émetteur pour chaque marchand

Par exemple, Foo-Loyalty gère des programmes de fidélité distincts pour deux marchands : ILuvCoffee et TeaLuv. Leurs classes de carte peuvent être gérées de l'une des manières suivantes :

Méthode	Description
Un seul compte d'émetteur	Regroupe toutes les classes de fidélité sous un seul compte d'émetteur "Foo-Loyalty". Cette option est recommandée si vous prévoyez d'effectuer le suivi des possibilités d'utilisation de vos cartes au niveau de la classe. Elle est également plus adaptée si vous n'accordez jamais aux marchands un accès API à ce compte d'émetteur.
Comptes d'émetteur distincts	Crée deux comptes d'émetteur distincts : "iLuvCoffee via Foo-Loyalty" et "teaLuv via Foo-Loyalty". Cette option est recommandée si vous préférez partir du principe que toutes les classes d'un compte d'émetteur donné peuvent être utilisées au niveau du marchand ou si vous prévoyez d'accorder aux marchands un accès API au compte d'émetteur.

Compte d'émetteur d'offres

Deux scénarios sont à prendre en compte pour déterminer le bon compte d'émetteur d'offres.

Scénario 1 : Le marchand utilise déjà Smart Tap

Si le marchand confirme qu'il peut déjà utiliser Smart Tap dans Google Wallet avec ses terminaux (le marchand est déjà configuré en tant qu'émetteur d'offres), procédez comme suit :

1. Demandez l'ID d'émetteur d'offres du marchand.
2. Ajoutez l'ID d'émetteur d'offres du marchand à la propriété redemptionIssuers de votre classe de carte.

Scénario 2 : Le marchand n'a jamais utilisé Smart Tap

Dans ce scénario, le marchand dispose de terminaux compatibles avec la fonctionnalité Smart Tap, mais ne l'a pas encore utilisée. Le marchand, le fournisseur de terminaux ou le développeur de cartes doit effectuer une configuration unique pour activer Smart Tap sur les terminaux du marchand.

Pour en savoir plus, consultez Configuration du marchand.