Expired Boarding passes

In Google Wallet, there's an "Expired passes" section that contains all archived or inactive passes.

A pass is moved to the "Expired passes" section if at least one of the following conditions is true:

  • It's been at least 24 hours since class.localScheduledDepartureDateTime or class.localEstimatedOrActualDepartureDateTime expired. The pass moves to "Expired passes" anytime between 24-48 hours after class.localScheduledDepartureDateTime or class.localEstimatedOrActualDepartureDateTime expires.
  • When the object.validTimeInterval.end.date expires, the pass moves to "Expired passes" anytime up to 24 hours after.
  • The state of the object object.state field is marked as Expired, Inactive, or Completed.

The following code sample demonstrates expiring a pass object using the Google Wallet API.

Java

To start your integration in Java, refer to our complete code samples on GitHub. 

/**
 * Expire an object.
 *
 * <p>Sets the object's state to Expired. If the valid time interval is already set, the pass will
 * expire automatically up to 24 hours after.
 *
 * @param issuerId The issuer ID being used for this request.
 * @param objectSuffix Developer-defined unique ID for this pass object.
 * @return The pass object ID: "{issuerId}.{objectSuffix}"
 */
public String expireObject(String issuerId, String objectSuffix) throws IOException {
  // Check if the object exists
  try {
    service.flightobject().get(String.format("%s.%s", issuerId, objectSuffix)).execute();
  } catch (GoogleJsonResponseException ex) {
    if (ex.getStatusCode() == 404) {
      // Object does not exist
      System.out.printf("Object %s.%s not found!%n", issuerId, objectSuffix);
      return String.format("%s.%s", issuerId, objectSuffix);
    } else {
      // Something else went wrong...
      ex.printStackTrace();
      return String.format("%s.%s", issuerId, objectSuffix);
    }
  }

  // Patch the object, setting the pass as expired
  FlightObject patchBody = new FlightObject().setState("EXPIRED");

  FlightObject response =
      service
          .flightobject()
          .patch(String.format("%s.%s", issuerId, objectSuffix), patchBody)
          .execute();

  System.out.println("Object expiration response");
  System.out.println(response.toPrettyString());

  return response.getId();
}

PHP

To start your integration in PHP, refer to our complete code samples on GitHub. 

/**
 * Expire an object.
 *
 * Sets the object's state to Expired. If the valid time interval is
 * already set, the pass will expire automatically up to 24 hours after.
 *
 * @param string $issuerId The issuer ID being used for this request.
 * @param string $objectSuffix Developer-defined unique ID for this pass object.
 *
 * @return string The pass object ID: "{$issuerId}.{$objectSuffix}"
 */
public function expireObject(string $issuerId, string $objectSuffix)
{
  // Check if the object exists
  try {
    $this->service->flightobject->get("{$issuerId}.{$objectSuffix}");
  } catch (Google\Service\Exception $ex) {
    if (!empty($ex->getErrors()) && $ex->getErrors()[0]['reason'] == 'resourceNotFound') {
      print("Object {$issuerId}.{$objectSuffix} not found!");
      return "{$issuerId}.{$objectSuffix}";
    } else {
      // Something else went wrong...
      print_r($ex);
      return "{$issuerId}.{$objectSuffix}";
    }
  }

  // Patch the object, setting the pass as expired
  $patchBody = new FlightObject([
    'state' => 'EXPIRED'
  ]);

  $response = $this->service->flightobject->patch("{$issuerId}.{$objectSuffix}", $patchBody);

  print "Object expiration response\n";
  print_r($response);

  return $response->id;
}

Python

To start your integration in Python, refer to our complete code samples on GitHub. 

def expire_object(self, issuer_id: str, object_suffix: str) -> str:
    """Expire an object.

    Sets the object's state to Expired. If the valid time interval is
    already set, the pass will expire automatically up to 24 hours after.

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

    Returns:
        The pass object ID: f"{issuer_id}.{object_suffix}"
    """

    # Check if the object exists
    try:
        response = self.client.flightobject().get(resourceId=f'{issuer_id}.{object_suffix}').execute()
    except HttpError as e:
        if e.status_code == 404:
            print(f'Object {issuer_id}.{object_suffix} not found!')
            return f'{issuer_id}.{object_suffix}'
        else:
            # Something else went wrong...
            print(e.error_details)
            return f'{issuer_id}.{object_suffix}'

    # Patch the object, setting the pass as expired
    patch_body = {'state': 'EXPIRED'}

    response = self.client.flightobject().patch(
        resourceId=f'{issuer_id}.{object_suffix}',
        body=patch_body).execute()

    print('Object expiration response')
    print(response)

    return f'{issuer_id}.{object_suffix}'

C#

To start your integration in C#, refer to our complete code samples on GitHub. 

/// <summary>
/// Expire an object.
/// <para />
/// Sets the object's state to Expired. If the valid time interval is already
/// set, the pass will expire automatically up to 24 hours after.
/// </summary>
/// <param name="issuerId">The issuer ID being used for this request.</param>
/// <param name="objectSuffix">Developer-defined unique ID for this pass object.</param>
/// <returns>The pass object ID: "{issuerId}.{objectSuffix}"</returns>
public string ExpireObject(string issuerId, string objectSuffix)
{
  // Check if the object exists
  Stream responseStream = service.Flightobject
      .Get($"{issuerId}.{objectSuffix}")
      .ExecuteAsStream();

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

  if (jsonResponse.ContainsKey("error"))
  {
    if (jsonResponse["error"].Value<int>("code") == 404)
    {
      // Object does not exist
      Console.WriteLine($"Object {issuerId}.{objectSuffix} not found!");
      return $"{issuerId}.{objectSuffix}";
    }
    else
    {
      // Something else went wrong...
      Console.WriteLine(jsonResponse.ToString());
      return $"{issuerId}.{objectSuffix}";
    }
  }

  // Patch the object, setting the pass as expired
  FlightObject patchBody = new FlightObject
  {
    State = "EXPIRED"
  };

  responseStream = service.Flightobject
      .Patch(patchBody, $"{issuerId}.{objectSuffix}")
      .ExecuteAsStream();

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

  Console.WriteLine("Object expiration response");
  Console.WriteLine(jsonResponse.ToString());

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

Node.js

To start your integration in Node, refer to our complete code samples on GitHub. 

/**
 * Expire an object.
 *
 * Sets the object's state to Expired. If the valid time interval is
 * already set, the pass will expire automatically up to 24 hours after.
 *
 * @param {string} issuerId The issuer ID being used for this request.
 * @param {string} objectSuffix Developer-defined unique ID for the pass object.
 *
 * @returns {string} The pass object ID: `${issuerId}.${objectSuffix}`
 */
async expireObject(issuerId, objectSuffix) {
  let response;

  // Check if the object exists
  try {
    response = await this.client.flightobject.get({
      resourceId: `${issuerId}.${objectSuffix}`
    });
  } catch (err) {
    if (err.response && err.response.status === 404) {
      console.log(`Object ${issuerId}.${objectSuffix} not found!`);
      return `${issuerId}.${objectSuffix}`;
    } else {
      // Something else went wrong...
      console.log(err);
      return `${issuerId}.${objectSuffix}`;
    }
  }

  // Patch the object, setting the pass as expired
  let patchBody = {
    'state': 'EXPIRED'
  };

  response = await this.client.flightobject.patch({
    resourceId: `${issuerId}.${objectSuffix}`,
    requestBody: patchBody
  });

  console.log('Object expiration response');
  console.log(response);

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

Go

To start your integration in Go, refer to our complete code samples on GitHub code samples on Github. 

// Expire an object.
//
// Sets the object's state to Expired. If the valid time interval is
// already set, the pass will expire automatically up to 24 hours after.
func (d *demoFlight) expireObject(issuerId, objectSuffix string) {
	flightObject := &walletobjects.FlightObject{
		State: "EXPIRED",
	}
	res, err := d.service.Flightobject.Patch(fmt.Sprintf("%s.%s", issuerId, objectSuffix), flightObject).Do()
	if err != nil {
		log.Fatalf("Unable to patch object: %v", err)
	} else {
		fmt.Printf("Object expiration id:\n%s\n", res.Id)
	}
}