Cette page a été traduite par l'API Cloud Translation.

Créer des classes et des objets de cartes

Presque toutes les cartes que vous pouvez émettre et qu'un utilisateur final peut enregistrer dans Google Wallet sont définies par deux composants: une classe Cartes et un objet Cartes. Chaque fois que vous émettez une carte à un utilisateur, vous avez besoin d'une instance de classe Cartes et d'un objet Cartes, qui indique à l'API Google Wallet le type de carte à créer et les informations à afficher sur la carte, comme la valeur d'une carte cadeau ou le nom d'un titulaire de billets.

L'API Google Wallet fournit un ensemble prédéfini de classes et d'objets de cartes dont vous créez des instances, puis vous utilisez pour créer une carte délivrée à un utilisateur, comme GiftCardClass et GiftCardObject, GenericClass et GenericObject, entre autres.

Chaque instance de classe de carte et d'objet de carte est définie comme un objet JSON, qui possède un ensemble de propriétés obligatoires et facultatives correspondant au cas d'utilisation spécifique prévu pour ce type de carte.

Créer une classe Cartes

Une classe Cartes peut être considérée comme un modèle partagé à partir duquel des cartes sont créées. Une classe Cartes définit certaines propriétés qui seront incluses dans toutes les cartes qui l'utilisent. Un émetteur de cartes peut créer plusieurs classes, chacune avec son propre ensemble de propriétés qui définissent des attributs tels que le style et l'apparence, ainsi que des fonctionnalités supplémentaires comme Smart Tap, ainsi que l'enregistrement et la connexion.

Les classes de cartes peuvent être créées à l'aide de l'API REST Google Wallet, du SDK Google Wallet pour Android ou dans la Business Console de Google Wallet.

Pour les nouveaux utilisateurs, Business Console est le moyen le plus simple de créer une classe Cartes. En effet, elle fournit une interface utilisateur simple dans laquelle vous pouvez définir les différents champs de votre première classe Cartes en remplissant des champs de formulaire.

Pour les utilisateurs avancés, la création de classes de carte par programmation est la meilleure approche.

Utiliser la Business Console de Google Wallet

Pour créer une classe Cartes dans la Business Console de Google Wallet, procédez comme suit:

Accédez à la Business Console de Google Pay et Wallet, puis connectez-vous avec votre compte d'émetteur de l'API Google Wallet.
Sur la fiche "API Google Wallet", cliquez sur le bouton "Gérer les cartes".
Sous "Obtenir l'accès en publication", cliquez sur le bouton "Créer un cours".
Sélectionnez un type de carte dans la boîte de dialogue. Google Wallet propose différents types de cartes (billet pour un événement, offre, carte de fidélité, etc.). Pour un cas d'utilisation flexible, sélectionnez "Générique" comme type de carte.
Renseignez les valeurs appropriées dans les champs obligatoires.
Cliquez sur le bouton "Créer un cours" pour enregistrer votre cours.

Utiliser l'API REST de Google Wallet

Pour créer une classe Cartes à l'aide de l'API REST Google Wallet, envoyez une requête POST à https://walletobjects.googleapis.com/walletobjects/v1/genericClass. Pour en savoir plus, consultez la documentation de référence.

Java

Pour commencer votre intégration en Java, consultez nos exemples de code complets sur GitHub.

/**
 * Create a class.
 *
 * @param issuerId The issuer ID being used for this request.
 * @param classSuffix Developer-defined unique ID for this pass class.
 * @return The pass class ID: "{issuerId}.{classSuffix}"
 */
public String createClass(String issuerId, String classSuffix) throws IOException {
  // Check if the class exists
  try {
    service.genericclass().get(String.format("%s.%s", issuerId, classSuffix)).execute();

    System.out.printf("Class %s.%s already exists!%n", issuerId, classSuffix);
    return String.format("%s.%s", issuerId, classSuffix);
  } catch (GoogleJsonResponseException ex) {
    if (ex.getStatusCode() != 404) {
      // Something else went wrong...
      ex.printStackTrace();
      return String.format("%s.%s", issuerId, classSuffix);
    }
  }

  // See link below for more information on required properties
  // https://developers.google.com/wallet/generic/rest/v1/genericclass
  GenericClass newClass = new GenericClass().setId(String.format("%s.%s", issuerId, classSuffix));

  GenericClass response = service.genericclass().insert(newClass).execute();

  System.out.println("Class insert response");
  System.out.println(response.toPrettyString());

  return response.getId();
}

PHP

Pour commencer votre intégration en PHP, consultez nos exemples de code complets sur GitHub.

/**
 * Create a class.
 *
 * @param string $issuerId The issuer ID being used for this request.
 * @param string $classSuffix Developer-defined unique ID for this pass class.
 *
 * @return string The pass class ID: "{$issuerId}.{$classSuffix}"
 */
public function createClass(string $issuerId, string $classSuffix)
{
  // Check if the class exists
  try {
    $this->service->genericclass->get("{$issuerId}.{$classSuffix}");

    print("Class {$issuerId}.{$classSuffix} already exists!");
    return "{$issuerId}.{$classSuffix}";
  } catch (Google\Service\Exception $ex) {
    if (empty($ex->getErrors()) || $ex->getErrors()[0]['reason'] != 'classNotFound') {
      // Something else went wrong...
      print_r($ex);
      return "{$issuerId}.{$classSuffix}";
    }
  }

  // See link below for more information on required properties
  // https://developers.google.com/wallet/generic/rest/v1/genericclass
  $newClass = new GenericClass([
    'id' => "{$issuerId}.{$classSuffix}"
  ]);

  $response = $this->service->genericclass->insert($newClass);

  print "Class insert response\n";
  print_r($response);

  return $response->id;
}

Python

Pour commencer votre intégration dans Python, consultez nos exemples de code complets sur GitHub.

def create_class(self, issuer_id: str, class_suffix: str) -> str:
    """Create a class.

    Args:
        issuer_id (str): The issuer ID being used for this request.
        class_suffix (str): Developer-defined unique ID for this pass class.

    Returns:
        The pass class ID: f"{issuer_id}.{class_suffix}"
    """

    # Check if the class exists
    try:
        self.client.genericclass().get(resourceId=f'{issuer_id}.{class_suffix}').execute()
    except HttpError as e:
        if e.status_code != 404:
            # Something else went wrong...
            print(e.error_details)
            return f'{issuer_id}.{class_suffix}'
    else:
        print(f'Class {issuer_id}.{class_suffix} already exists!')
        return f'{issuer_id}.{class_suffix}'

    # See link below for more information on required properties
    # https://developers.google.com/wallet/generic/rest/v1/genericclass
    new_class = {'id': f'{issuer_id}.{class_suffix}'}

    response = self.client.genericclass().insert(body=new_class).execute()

    print('Class insert response')
    print(response)

    return f'{issuer_id}.{class_suffix}'

C#

Pour commencer l'intégration en C#, consultez nos exemples de code complets sur GitHub.

/// <summary>
/// Create a class.
/// </summary>
/// <param name="issuerId">The issuer ID being used for this request.</param>
/// <param name="classSuffix">Developer-defined unique ID for this pass class.</param>
/// <returns>The pass class ID: "{issuerId}.{classSuffix}"</returns>
public string CreateClass(string issuerId, string classSuffix)
{
  // Check if the class exists
  Stream responseStream = service.Genericclass
      .Get($"{issuerId}.{classSuffix}")
      .ExecuteAsStream();

  StreamReader responseReader = new StreamReader(responseStream);
  JObject jsonResponse = JObject.Parse(responseReader.ReadToEnd());

  if (!jsonResponse.ContainsKey("error"))
  {
    Console.WriteLine($"Class {issuerId}.{classSuffix} already exists!");
    return $"{issuerId}.{classSuffix}";
  }
  else if (jsonResponse["error"].Value<int>("code") != 404)
  {
    // Something else went wrong...
    Console.WriteLine(jsonResponse.ToString());
    return $"{issuerId}.{classSuffix}";
  }

  // See link below for more information on required properties
  // https://developers.google.com/wallet/generic/rest/v1/genericclass
  GenericClass newClass = new GenericClass
  {
    Id = $"{issuerId}.{classSuffix}"
  };

  responseStream = service.Genericclass
      .Insert(newClass)
      .ExecuteAsStream();

  responseReader = new StreamReader(responseStream);
  jsonResponse = JObject.Parse(responseReader.ReadToEnd());

  Console.WriteLine("Class insert response");
  Console.WriteLine(jsonResponse.ToString());

  return $"{issuerId}.{classSuffix}";
}

Node.js

Pour commencer votre intégration dans Node, consultez nos exemples de code complets sur GitHub.

/**
 * Create a class.
 *
 * @param {string} issuerId The issuer ID being used for this request.
 * @param {string} classSuffix Developer-defined unique ID for this pass class.
 *
 * @returns {string} The pass class ID: `${issuerId}.${classSuffix}`
 */
async createClass(issuerId, classSuffix) {
  let response;

  // Check if the class exists
  try {
    response = await this.client.genericclass.get({
      resourceId: `${issuerId}.${classSuffix}`
    });

    console.log(`Class ${issuerId}.${classSuffix} already exists!`);

    return `${issuerId}.${classSuffix}`;
  } catch (err) {
    if (err.response && err.response.status !== 404) {
      // Something else went wrong...
      console.log(err);
      return `${issuerId}.${classSuffix}`;
    }
  }

  // See link below for more information on required properties
  // https://developers.google.com/wallet/generic/rest/v1/genericclass
  let newClass = {
    'id': `${issuerId}.${classSuffix}`
  };

  response = await this.client.genericclass.insert({
    requestBody: newClass
  });

  console.log('Class insert response');
  console.log(response);

  return `${issuerId}.${classSuffix}`;
}

Go

Pour commencer l'intégration dans Go, reportez-vous à nos exemples de code complets sur GitHub ( exemples de code sur GitHub).

// Create a class.
func (d *demoGeneric) createClass(issuerId, classSuffix string) {
	genericClass := new(walletobjects.GenericClass)
	genericClass.Id = fmt.Sprintf("%s.%s", issuerId, classSuffix)
	res, err := d.service.Genericclass.Insert(genericClass).Do()
	if err != nil {
		log.Fatalf("Unable to insert class: %v", err)
	} else {
		fmt.Printf("Class insert id:\n%v\n", res.Id)
	}
}

Créer un objet Cartes

Un objet Cartes est une instance d'une classe Cartes. Pour créer un objet Cartes, vous devez fournir les attributs suivants:

classId: id de la classe Cartes

id: identifiant unique de votre client

Exemple de code permettant de créer un objet Cartes: