Ta strona została przetłumaczona przez Cloud Translation API.

Tworzenie klas kart i obiektów kart

Prawie wszystkie karty, które użytkownik może zapisać w Portfelu Google, są zdefiniowane przez 2 komponenty: klasę kart i obiekt karty. Za każdym razem, gdy wydajesz kartę użytkownikowi, potrzebujesz wystąpienia zarówno klasy kart, jak i obiektu kart. Informuje on interfejs API Portfela Google, jaki typ karty ma utworzyć, oraz podaj szczegóły, które mają się na niej wyświetlać, takie jak wartość karty podarunkowej czy imię i nazwisko posiadacza biletu.

Interfejs API Portfela Google udostępnia wstępnie zdefiniowany zestaw klas i obiektów kart kart, które możesz utworzyć, a następnie użyć do utworzenia karty wydanej użytkownikowi, np. GiftCardClass i GiftCardObject, GenericClass, GenericObject itp.

Każda instancja obiektu klas i kart biletów jest zdefiniowana jako obiekt JSON ze zbiorem wymaganych i opcjonalnych właściwości odpowiadających konkretnemu przypadekowi użycia przeznaczonemu dla danego typu karty.

Utwórz klasę kart

Klasa kart może być traktowana jako udostępniany szablon, na podstawie którego są tworzone karty. Klasa kart definiuje określone właściwości, które zostaną włączone do wszystkich kart, które z niej korzystają. Wydawca karty może tworzyć wiele klas, z których każda ma własny zestaw właściwości definiujących atrybuty, na przykład styl i wygląd, a także dodatkowe funkcje, takie jak Smart Tap czy Rejestracja i Logowanie.

Klasy kart można tworzyć za pomocą interfejsu API typu REST Portfela Google, pakietu SDK Portfela Google na Androida lub w Google Wallet Business Console.

W przypadku nowych użytkowników Business Console jest najprostszym sposobem na rozpoczęcie tworzenia klasy kart, ponieważ ma prosty interfejs użytkownika, w którym można zdefiniować różne pola pierwszej klasy kart poprzez wypełnienie pól formularza.

W przypadku zaawansowanych użytkowników najlepszym sposobem jest automatyczne utworzenie klas kart.

Korzystanie z Portfela Google Business Console

Aby utworzyć klasę kart w konsoli Google Wallet Business:

Otwórz Google Pay and Wallet Business Console i zaloguj się na swoje konto wydawcy interfejsu API Portfela Google.
Na „Google Wallet API” kliknij „Zarządzaj kartami”. Przycisk
W sekcji „Uzyskaj dostęp do publikowania” kliknij „Utwórz zajęcia”. Przycisk
Wybierz typ karty w oknie. Portfel Google oferuje różne typy kart (bilety na wydarzenia, oferty specjalne, karty lojalnościowe itp.). Aby wybrać elastyczny przypadek użycia, wybierz „Ogólne” jako typ karty.
Wpisz odpowiednie wartości w wymaganych polach.
Kliknij „Utwórz zajęcia”. , aby zapisać zajęcia.

Używanie interfejsu API typu REST Portfela Google

Aby utworzyć klasę kart za pomocą interfejsu API typu REST Portfela Google, wyślij żądanie POST do https://walletobjects.googleapis.com/walletobjects/v1/genericClass. Więcej informacji znajdziesz w dokumentacji referencyjnej.

Java

Aby rozpocząć integrację w Javie, zapoznaj się z pełną wersją na GitHubie.

/**
 * 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

Aby rozpocząć integrację w języku PHP, zapoznaj się z pełnym na GitHubie.

/**
 * 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

Aby rozpocząć integrację w Pythonie, zapoznaj się z pełną wersją na GitHubie.

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#

Aby rozpocząć integrację w języku C#, zapoznaj się z pełnym na GitHubie.

/// <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

Aby rozpocząć integrację w Node, zapoznaj się z pełną wersją na GitHubie.

/**
 * 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}`;
}

Przeczytaj

Aby rozpocząć integrację w języku Go, zapoznaj się z naszymi pełnymi przykładami kodu na GitHubie na GitHubie.

// 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)
	}
}

Tworzenie obiektu kart

Obiekt Karty jest instancją klasy kart. Aby utworzyć karty Object, musisz podać te atrybuty:

classId: id klasy kart

id: unikalny identyfikator klienta

Przykładowy kod do tworzenia obiektu Karty: