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

Créer des classes de cartes et des objets Cartes

Presque toutes les cartes que vous pouvez émettre pour qu'un utilisateur final les enregistre dans son compte Google Wallet sont définies par deux composants: une classe Cartes et un objet Cartes. Chaque fois que vous envoyez 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, ainsi que les informations à afficher sur la carte, comme la valeur d'une carte cadeau ou le nom d'un détenteur de billet.

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

Chaque classe d'objet Cartes et chaque instance d'objet Cartes est définie en tant qu'objet JSON, qui possède un ensemble de propriétés obligatoires et facultatives correspondant au cas d'utilisation spécifique destiné à ce type de carte.

Créer une classe de carte

Une classe Cartes peut être considérée comme un modèle partagé à partir duquel sont créées des cartes. 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 distinct 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, l'enregistrement et la connexion.

Vous pouvez créer des classes de carte à l'aide de l'API REST de Google Wallet, du SDK Google Wallet pour Android ou de la Business Console de Google Wallet.

Pour les nouveaux utilisateurs, la Business Console est le moyen le plus simple de commencer à créer une classe de carte. 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 les champs de formulaire.

La création programmatique de classes de cartes est la meilleure approche pour les utilisateurs avancés.

Utiliser la Business Console de Google Wallet

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

Accédez à la Google Pay and Wallet Business Console et connectez-vous avec votre compte d'émetteur pour l'API Google Wallet.
Sur l'API Google Wallet cliquez sur "Gérer les cartes", .
Sous "Obtenir l'accès en publication", cliquez sur "Créer un cours". .
Choisissez 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 champs obligatoires.
Cliquez sur le bouton "Créer un cours" pour enregistrer votre cours.

Utiliser l'API REST Google Wallet

Pour créer une classe de carte à 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, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code 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 l'intégration en PHP, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code 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 l'intégration dans Python, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code 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 votre intégration en C#, consultez notre <ph type="x-smartling-placeholder"></ph> exemples de code 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, reportez-vous à notre <ph type="x-smartling-placeholder"></ph> exemples de code 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 votre intégration dans Go, consultez nos exemples de code complets sur GitHub. <ph type="x-smartling-placeholder"></ph> 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 une carte objet, 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: