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

Tworzenie klas kart i obiektów kart

Prawie wszystkie karty, które możesz wydać użytkownikowi, aby zapisać je w swoim Portfelu Google, są definiowane przez 2 komponenty: klasę kart i obiekt kart. Za każdym razem, gdy wydajesz użytkownikowi kartę, konieczne jest wystąpienie zarówno klasy karty, jak i obiektu Pass Object. Informuje on interfejs Google Wallet API o typie karty do utworzenia, a także szczegóły, które mają być widoczne na karcie, takie jak wartość karty podarunkowej lub imię i nazwisko posiadacza biletu.

Interfejs Google Wallet API udostępnia wstępnie zdefiniowany zestaw klas i obiektów kart, których możesz używać do tworzenia wystąpień kart, które są wydawane dla użytkowników, takich jak GiftCardClass, GiftCardObject, GenericClass i GenericObject.

Każda instancja klasy i obiektu kart jest zdefiniowana jako obiekt JSON, który ma zestaw wymaganych i opcjonalnych właściwości odpowiadających konkretnemu przypadkowi użycia przeznaczonemu dla danego typu karty.

Utwórz klasę kart

Klasa kart można określić jako udostępniony szablon, na podstawie którego tworzone są karty. Klasa kart definiuje określone właściwości, które będą uwzględniane we wszystkich kartach, które z niej korzystają. Wystawca karty może utworzyć wiele klas, każdą z osobnym zestawem właściwości definiujących atrybuty, takich jak 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 Portfela Google typu REST, pakietu SDK Portfela Google na Androida lub w konsoli biznesowej Portfela Google.

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

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

Korzystanie z konsoli biznesowej Portfela Google

Aby utworzyć klasę kart w konsoli Portfela Google Business, wykonaj te czynności:

Otwórz konsolę firmową usług Google Pay i Portfela Google i zaloguj się na swoje konto wydawcy interfejsu API Portfela Google.
Na karcie „Google Wallet API” kliknij przycisk „Zarządzaj kartami”.
W sekcji „Uzyskaj dostęp do publikowania” kliknij przycisk „Utwórz zajęcia”.
W oknie wybierz typ karty. Portfel Google oferuje różne typy kart (bilet na wydarzenia, oferty specjalne, karty lojalnościowe itp.). W przypadku elastycznego przypadku użycia jako typ karty wybierz „Ogólny”.
Wpisz odpowiednie wartości w wymaganych polach.
Kliknij przycisk „Utwórz zajęcia”, aby zapisać swoje zajęcia.

Użyj interfejsu API Portfela Google typu REST

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

Java

Aby rozpocząć integrację w Javie, zapoznaj się z kompletnymi przykładami kodu 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.flightclass().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/tickets/boarding-passes/rest/v1/flightclass
  FlightClass newClass =
      new FlightClass()
          .setId(String.format("%s.%s", issuerId, classSuffix))
          .setIssuerName("Issuer name")
          .setReviewStatus("UNDER_REVIEW")
          .setLocalScheduledDepartureDateTime("2023-07-02T15:30:00")
          .setFlightHeader(
              new FlightHeader()
                  .setCarrier(new FlightCarrier().setCarrierIataCode("LX"))
                  .setFlightNumber("123"))
          .setOrigin(new AirportInfo().setAirportIataCode("LAX").setTerminal("1").setGate("A2"))
          .setDestination(
              new AirportInfo().setAirportIataCode("SFO").setTerminal("2").setGate("C3"));

  FlightClass response = service.flightclass().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łnymi przykładami kodu 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 {
    $response = $this->service->flightclass->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/tickets/boarding-passes/rest/v1/flightclass
  $newClass = new FlightClass([
    'id' => "{$issuerId}.{$classSuffix}",
    'issuerName' => 'Issuer name',
    'reviewStatus' => 'UNDER_REVIEW',
    'localScheduledDepartureDateTime' => '2023-07-02T15:30:00',
    'flightHeader' => new FlightHeader([
      'carrier' => new FlightCarrier([
        'carrierIataCode' => 'LX'
      ]),
      'flightNumber' => '123'
    ]),
    'origin' => new AirportInfo([
      'airportIataCode' => 'LAX',
      'terminal' => '1',
      'gate' => 'A2'
    ]),
    'destination' => new AirportInfo([
      'airportIataCode' => 'SFO',
      'terminal' => '2',
      'gate' => 'C3'
    ])
  ]);

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

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

  return $response->id;
}

Python

Aby rozpocząć integrację w Pythonie, zapoznaj się z kompletnymi przykładami kodu w 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.flightclass().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/tickets/events/rest/v1/eventticketclass
    new_class = {
        'id': f'{issuer_id}.{class_suffix}',
        'issuerName': 'Issuer name',
        'reviewStatus': 'UNDER_REVIEW',
        'localScheduledDepartureDateTime': '2023-07-02T15:30:00',
        'flightHeader': {
            'carrier': {
                'carrierIataCode': 'LX'
            },
            'flightNumber': '123'
        },
        'origin': {
            'airportIataCode': 'LAX',
            'terminal': '1',
            'gate': 'A2'
        },
        'destination': {
            'airportIataCode': 'SFO',
            'terminal': '2',
            'gate': 'C3'
        }
    }

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

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

    return f'{issuer_id}.{class_suffix}'

C#

Aby rozpocząć integrację w C#, zapoznaj się z kompletnymi przykładami kodu 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.Flightclass
      .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/tickets/boarding-passes/rest/v1/flightclass
  FlightClass newClass = new FlightClass
  {
    Id = $"{issuerId}.{classSuffix}",
    IssuerName = "Issuer name",
    ReviewStatus = "UNDER_REVIEW",
    LocalScheduledDepartureDateTime = "2023-07-02T15:30:00",
    FlightHeader = new FlightHeader
    {
      Carrier = new FlightCarrier
      {
        CarrierIataCode = "LX"
      },
      FlightNumber = "123"
    },
    Origin = new AirportInfo
    {
      AirportIataCode = "LAX",
      Terminal = "1",
      Gate = "A2"
    },
    Destination = new AirportInfo
    {
      AirportIataCode = "SFO",
      Terminal = "2",
      Gate = "C3"
    }
  };

  responseStream = service.Flightclass
      .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 kompletnymi przykładami kodu 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.flightclass.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/tickets/boarding-passes/rest/v1/flightclass
  let newClass = {
    'id': `${issuerId}.${classSuffix}`,
    'issuerName': 'Issuer name',
    'reviewStatus': 'UNDER_REVIEW',
    'localScheduledDepartureDateTime': '2023-07-02T15:30:00',
    'flightHeader': {
      'carrier': {
        'carrierIataCode': 'LX'
      },
      'flightNumber': '123'
    },
    'origin': {
      'airportIataCode': 'LAX',
      'terminal': '1',
      'gate': 'A2'
    },
    'destination': {
      'airportIataCode': 'SFO',
      'terminal': '2',
      'gate': 'C3'
    }
  };

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

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

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

Go

Aby rozpocząć integrację w Go, zapoznaj się z kompletnymi przykładami kodu w GitHubie i zapoznaj się z przykładami kodu w GitHubie.

// Create a class.
func (d *demoFlight) createClass(issuerId, classSuffix string) {
	flightClass := new(walletobjects.FlightClass)
	flightClass.Id = fmt.Sprintf("%s.%s", issuerId, classSuffix)
	flightClass.ReviewStatus = "UNDER_REVIEW"
	flightClass.IssuerName = "Issuer name"
	flightClass.Origin = &walletobjects.AirportInfo{
		Terminal:        "1",
		Gate:            "A2",
		AirportIataCode: "LAX",
	}
	flightClass.Destination = &walletobjects.AirportInfo{
		Terminal:        "2",
		Gate:            "C3",
		AirportIataCode: "SFO",
	}
	flightClass.FlightHeader = &walletobjects.FlightHeader{
		Carrier: &walletobjects.FlightCarrier{
			CarrierIataCode: "LX",
		},
		FlightNumber: "123",
	}
	flightClass.LocalScheduledDepartureDateTime = "2023-06-12T23:20:50"

	res, err := d.service.Flightclass.Insert(flightClass).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 kart jest instancją klasy kart. Aby utworzyć obiekt kart, musisz podać te atrybuty:

classId: id klasy kart

id: unikalny identyfikator klienta.

Więcej informacji o sposobie prezentowania tych atrybutów na karcie pokładowej znajdziesz w szablonie układu.

Przykładowy kod umożliwiający utworzenie obiektu kart: