Build-Reservierungen

In diesem Leitfaden wird beschrieben, wie Sie ein Actions-Projekt entwickeln, bei dem die Orders API für Reservierungen verwendet wird.

Transaktionsablauf

Wenn Ihr Actions-Projekt Reservierungen verarbeitet, wird der folgende Ablauf verwendet:

  1. Transaktionsanforderungen validieren (optional): Verwenden Sie zu Beginn der Unterhaltung die Hilfe für Transaktionsanforderungen, um zu prüfen, ob der Nutzer in der Lage ist, eine Transaktion auszuführen.
  2. Bestellung erstellen: Gehe mit dem Nutzer durch eine „Wagenmontage“, in der er die Details seiner Reservierung zusammenstellt.
  3. Bestellung vorschlagen: Sobald der Einkaufswagen fertig ist, schlagen Sie dem Nutzer die Reservierung „Bestellung“ vor, damit er bestätigen kann, dass sie korrekt ist. Wenn die Reservierung bestätigt wird, erhalten Sie eine Antwort mit Reservierungsdetails.
  4. Bestellung abschließen und Beleg senden: Aktualisieren Sie nach Bestätigung der Bestellung Ihr Reservierungssystem und senden Sie eine Quittung an den Nutzer.
  5. Bestellaktualisierungen senden: Aktualisiere den Reservierungsstatus der Nutzer während der Laufzeit der Reservierung, indem du PATCH-Anfragen an die Orders API sendest.

Einschränkungen und Richtlinien für Überprüfungen

Für Aktionen, die die Transaktions- und die Orders API verwenden, gelten zusätzliche Richtlinien. Es kann bis zu sechs Wochen dauern, bis wir Aktionen mit Transaktionen überprüft haben. Berücksichtigen Sie diese Zeit daher bei der Planung Ihres Release-Zeitplans. Achte darauf, dass du die Richtlinien für Transaktionen einhältst, bevor du deine Aktion zur Überprüfung einreichst, um den Überprüfungsprozess zu vereinfachen.

Sie können Aktionen, die die Orders API verwenden, nur in den folgenden Ländern bereitstellen:

Australien
Brasilien
Kanada
Indonesien
Japan
Mexiko
Katar
Russland
Singapur
Schweiz
Thailand
Türkei
Vereinigtes Königreich
USA

Ihr Projekt erstellen

Ein ausführliches Beispiel für transaktionale Unterhaltungen finden Sie in unserem Transaktionsbeispiel in Node.js.

Einrichtung

Beim Erstellen einer Aktion müssen Sie in der Actions Console angeben, dass Sie Transaktionen ausführen möchten.

So richten Sie Ihr Projekt und die Auftragsausführung ein:

  1. Erstellen Sie ein neues Projekt oder importieren Sie ein vorhandenes Projekt.
  2. Gehen Sie zu Bereitstellen > Verzeichnisinformationen.
  3. Klicke unter Zusätzliche Informationen > Transaktionen auf das Kästchen neben "Verwenden deine Aktionen die Transactions API, um Transaktionen mit physischen Waren durchzuführen?".

Transaktionsanforderungen validieren (optional)

Sobald der Nutzer angegeben hat, dass er eine Reservierung einrichten möchte, sollten Sie prüfen, ob er in der Lage ist, eine Reservierung anzufordern. Wenn Ihre Aktion beispielsweise aufgerufen wird, kann sie fragen: "Möchten Sie einen Platz reservieren?" Wenn der Nutzer „Ja“ sagt, sollten Sie dafür sorgen, dass er fortfahren kann, und ihm die Möglichkeit geben, alle Einstellungen zu korrigieren, die die Transaktion verhindern. Wechseln Sie dazu zu einer Szene, die eine Prüfung der Transaktionsanforderungen durchführt.

Prüfung der Transaktionsanforderungen erstellen

  1. Fügen Sie auf dem Tab Szenen eine neue Szene mit dem Namen TransactionRequirementsCheck hinzu.
  2. Klicken Sie unter Slot-Füllung auf +, um eine neue Anzeigenfläche hinzuzufügen.
  3. Wählen Sie unter Typ auswählen actions.type.TransactionRequirementsCheckResult als Slottyp aus.
  4. Geben Sie der Anzeigenfläche den Namen TransactionRequirementsCheck im Feld für den Slotnamen.
  5. Klicken Sie das Kästchen Rückschreibe für Slotwert anpassen an (standardmäßig aktiviert).
  6. Klicken Sie auf Speichern.

Eine Prüfung der Transaktionsanforderungen führt zu einem der folgenden Ergebnisse:

  • Wenn die Anforderungen erfüllt sind, wird der Sitzungsparameter mit einer Erfolgsbedingung festgelegt und Sie können mit der Erstellung des Auftrags des Nutzers fortfahren.
  • Wenn eine oder mehrere Anforderungen nicht erfüllt werden können, wird der Sitzungsparameter mit einer Fehlerbedingung festgelegt. In diesem Fall sollten Sie die Unterhaltung weg von der Transaktionserfahrung lenken oder sie beenden.
    • Wenn Fehler, die zum Fehlerstatus führen, vom Nutzer behoben werden können, wird er aufgefordert, diese Probleme auf seinem Gerät zu beheben. Wenn die Unterhaltung auf einer sprachgesteuerten Oberfläche stattfindet, wird eine Übergabe an das Smartphone des Nutzers initiiert.

Ergebnis der Prüfung für Transaktionsanforderungen verarbeiten

  1. Wählen Sie auf dem Tab Szenen die neu erstellte Szene TransactionRequirementsCheck aus.
  2. Klicken Sie unter Bedingung auf +, um eine neue Bedingung hinzuzufügen.
  3. Geben Sie die folgende Bedingungssyntax in das Textfeld ein, um zu prüfen, ob die Erfolgsbedingung erfüllt ist:

    scene.slots.status == "FINAL" && session.params.TransactionRequirementsCheck.resultType == "CAN_TRANSACT"
    
  4. Bewegen Sie den Mauszeiger auf die soeben hinzugefügte Bedingung und klicken Sie auf den Pfeil nach oben, um sie vor if scene.slots.status == "FINAL" zu platzieren.

  5. Aktivieren Sie Aufforderungen senden und blenden Sie eine einfache Eingabeaufforderung ein, die den Nutzer darüber informiert, dass er für eine Transaktion bereit ist:

    candidates:
      - first_simple:
          variants:
            - speech: >-
                Looks like you're good to go!.
    
  6. Wählen Sie unter Übergang eine andere Szene aus, sodass der Nutzer die Unterhaltung fortsetzen und mit der Transaktion fortfahren kann.

  7. Wählen Sie die Bedingung else if scene.slots.status == "FINAL" aus.

  8. Aktivieren Sie Aufforderungen senden und blenden Sie eine einfache Aufforderung ein, die den Nutzer darüber informiert, dass er keine Transaktion vornehmen kann:

    candidates:
      - first_simple:
          variants:
            - speech: Transaction requirements check failed.
    
  9. Wählen Sie unter Umstellung die Option Unterhaltung beenden aus, um die Unterhaltung zu beenden, wenn ein Nutzer keine Transaktionen vornehmen kann.

Auftrag erstellen

Sobald Sie die benötigten Nutzerinformationen haben, erstellen Sie eine „Einkaufswagenmontage“, die den Nutzer beim Erstellen der Reservierung anleitet. Jede Aktion hat je nach Dienst einen etwas anderen Montageablauf für den Warenkorb.

Bei der einfachen Zusammensetzung eines Einkaufswagens wählt ein Nutzer Optionen aus einer Liste aus, die er zu seiner Reservierung hinzufügen möchte. Sie können die Unterhaltung jedoch so gestalten, dass die User Experience vereinfacht wird. Erstellen Sie beispielsweise einen Warenkorbbau, der es dem Nutzer ermöglicht, mit einer einfachen Ja- oder Nein-Frage eine monatliche Reservierung zu vereinbaren. Sie können dem Nutzer auch ein Karussell oder eine Listenkarte mit „empfohlenen“ Reservierungen präsentieren.

Wir empfehlen die Verwendung von Rich-Media-Antworten, um die Optionen des Nutzers visuell darzustellen, aber gestalte die Konversation auch so, dass der Nutzer seinen Warenkorb nur mit seiner Stimme erstellen kann. Einige Best Practices und Beispiele für den Zusammenbau von Warenwagen finden Sie in den Designrichtlinien.

Auftrag erstellen

Erfassen Sie während der Unterhaltung die Reservierungsdetails des Nutzers und erstellen Sie dann ein Order-Objekt.

Die Order muss mindestens Folgendes enthalten:

  • buyerInfo: Informationen zum Nutzer, der den Kauf tätigt
  • transactionMerchant: Informationen zum Händler, der die Bestellung durchgeführt hat.
  • contents: Der tatsächliche Inhalt des Auftrags, der als lineItems aufgeführt ist.

Informationen zum Erstellen des Einkaufswagens findest du in der Dokumentation zu Order-Antworten. Je nach Reservierung müssen Sie möglicherweise unterschiedliche Felder einfügen.

Der folgende Beispielcode zeigt einen vollständigen Reservierungsauftrag mit optionalen Feldern:

const order = {
   createTime: '2019-09-24T18:00:00.877Z',
   lastUpdateTime: '2019-09-24T18:00:00.877Z',
   merchantOrderId: orderId, // A unique ID String for the order
   userVisibleOrderId: orderId,
   transactionMerchant: {
     id: 'http://www.example.com',
     name: 'Example Merchant',
   },
   contents: {
     lineItems: [
       {
         id: 'LINE_ITEM_ID',
         name: 'Dinner reservation',
         description: 'A world of flavors all in one destination.',
         reservation: {
           status: 'PENDING',
           userVisibleStatusLabel: 'Reservation is pending.',
           type: 'RESTAURANT',
           reservationTime: {
             timeIso8601: '2020-01-16T01:30:15.01Z',
           },
           userAcceptableTimeRange: {
             timeIso8601: '2020-01-15/2020-01-17',
           },
           partySize: 6,
           staffFacilitators: [
             {
               name: 'John Smith',
             },
           ],
           location: {
             zipCode: '94086',
             city: 'Sunnyvale',
             postalAddress: {
               regionCode: 'US',
               postalCode: '94086',
               administrativeArea: 'CA',
               locality: 'Sunnyvale',
               addressLines: [
                 '222, Some other Street',
               ],
             },
           },
         },
       },
     ],
   },
   buyerInfo: {
     email: 'janedoe@gmail.com',
     firstName: 'Jane',
     lastName: 'Doe',
     displayName: 'Jane Doe',
   },
   followUpActions: [
     {
       type: 'VIEW_DETAILS',
       title: 'View details',
       openUrlAction: {
         url: 'http://example.com',
       },
     },
     {
       type: 'CALL',
       title: 'Call us',
       openUrlAction: {
         url: 'tel:+16501112222',
       },
     },
     {
       type: 'EMAIL',
       title: 'Email us',
       openUrlAction: {
         url: 'mailto:person@example.com',
       },
     },
   ],
   termsOfServiceUrl: 'http://www.example.com'
 };

Auftrags- und Präsentationsoptionen erstellen

const orderOptions = {
      'requestDeliveryAddress': false,
    };

const presentationOptions = {
      'actionDisplayName': 'RESERVE'
    };

Bestelldaten im Sitzungsparameter speichern

Speichern Sie die Bestelldaten aus der Auftragsausführung in einem Sitzungsparameter. Das Order-Objekt wird szenenübergreifend für dieselbe Sitzung verwendet.

conv.session.params.order = {
    '@type': 'type.googleapis.com/google.actions.transactions.v3.TransactionDecisionValueSpec',
    order: order,
    orderOptions: orderOptions,
    presentationOptions: presentationOptions
};

Auftrag vorschlagen

Nachdem Sie einen Reservierungsauftrag erstellt haben, müssen Sie ihn dem Nutzer zur Bestätigung oder Ablehnung vorlegen. Wechseln Sie dazu zu einer Szene, die eine Transaktionsentscheidung ausführt.

Szene für Transaktionsentscheidung erstellen

  1. Fügen Sie auf dem Tab Szenen eine neue Szene mit dem Namen TransactionDecision hinzu.
  2. Klicken Sie unter Slot-Füllung auf +, um eine neue Anzeigenfläche hinzuzufügen.
  3. Wählen Sie unter Typ auswählen actions.type.TransactionDecisionValue als Slottyp aus.
  4. Geben Sie der Anzeigenfläche den Namen TransactionDecision im Feld für den Slotnamen.
  5. Klicken Sie das Kästchen Rückschreibe für Slotwert anpassen an (standardmäßig aktiviert).
  6. Wählen Sie unter Slot konfigurieren im Drop-down-Menü die Option Sitzungsparameter verwenden aus.
  7. Geben Sie unter Slot konfigurieren im Textfeld den Namen des Sitzungsparameters ein,mit dem die Bestellung gespeichert wird (z.B. $session.params.order).
  8. Klicken Sie auf Speichern.

Beim Versuch, einen TransactionDecisionValue-Slot zu füllen, initiiert Assistant eine integrierte Funktion, bei der die übergebene Order direkt auf einer „Warenkorbvorschaukarte“ gerendert wird. Der Nutzer kann „Termin vereinbaren“ sagen, die Transaktion ablehnen oder eine Änderung der Reservierungsdetails anfordern.

An dieser Stelle kann der Nutzer auch Änderungen an der Bestellung anfordern. In diesem Fall sollten Sie dafür sorgen, dass die Auftragsausführung nach Abschluss der Warenkorbmontage Anfragen zu Bestelländerungen bearbeiten kann.

Transaktionsentscheidungsergebnis verarbeiten

Wenn ein TransactionDecisionValue-Slot gefüllt wird, wird die Antwort des Nutzers auf die Transaktionsentscheidung in einem Sitzungsparameter gespeichert. Dieser Wert enthält Folgendes:

  • ORDER_ACCEPTED,
  • ORDER_REJECTED,
  • CART_CHANGE_REQUESTED
  • USER_CANNOT_TRANSACT.

So verarbeiten Sie das Ergebnis einer Transaktionsentscheidung:

  1. Wählen Sie auf dem Tab Szenen die neu erstellte Szene TransactionDecision aus.
  2. Klicken Sie unter Bedingung auf +, um eine neue Bedingung hinzuzufügen.
  3. Geben Sie die folgende Bedingungssyntax in das Textfeld ein, um zu prüfen, ob die Erfolgsbedingung erfüllt ist:

    scene.slots.status == "FINAL" && session.params.TransactionDecision.transactionDecision == "ORDER_ACCEPTED"
    
  4. Bewegen Sie den Mauszeiger auf die soeben hinzugefügte Bedingung und klicken Sie auf den Pfeil nach oben, um sie vor if scene.slots.status == "FINAL" zu platzieren.

  5. Aktivieren Sie Aufforderungen senden und geben Sie eine einfache Aufforderung an, die den Nutzer darüber informiert, dass die Reservierung abgeschlossen ist:

    candidates:
      - first_simple:
          variants:
            - speech: >-
                Transaction completed! Your reservation
                $session.params.TransactionDecision.order.merchantOrderId is all
                set!
    
  6. Wählen Sie unter Umstellung die Option Unterhaltung beenden aus.

  7. Klicken Sie unter Bedingung auf +, um eine neue Bedingung hinzuzufügen.

  8. Geben Sie in das Textfeld die folgende Bedingungssyntax ein, um nach den Fehlerbedingungen zu suchen:

      scene.slots.status == "FINAL" && session.params.TransactionDecision.transactionDecision == "ORDER_REJECTED"
    
  9. Bewegen Sie den Mauszeiger auf die soeben hinzugefügte Bedingung und klicken Sie auf den Pfeil nach oben, um sie vor if scene.slots.status == "FINAL" zu platzieren.

  10. Aktivieren Sie Sendprompts (Aufforderungen senden) und geben Sie dem Nutzer mit einer einfachen Aufforderung Bescheid, dass die Bestellung abgelehnt wurde:

    candidates:
      - first_simple:
          variants:
            - speech: Looks like you don't want to set up a reservation. Goodbye.
    
  11. Wählen Sie unter Umstellung die Option Unterhaltung beenden aus.

  12. Wählen Sie die Bedingung else if scene.slots.status == "FINAL" aus.

  13. Aktivieren Sie Aufforderungen senden und blenden Sie eine einfache Aufforderung ein, die den Nutzer darüber informiert, dass eine Transaktion nicht möglich ist:

    candidates:
      - first_simple:
          variants:
            - speech: >-
                Transaction failed with status
                $session.params.TransactionDecision.transactionDecision
    
  14. Wählen Sie unter Umstellung die Option Unterhaltung beenden aus, um die Unterhaltung zu beenden, wenn ein Nutzer keine Transaktionen vornehmen kann.

Reservierung abschließen und Beleg senden

Wenn der Slot TransactionDecisionValue das Ergebnis ORDER_ACCEPTED zurückgibt, müssen Sie sofort die Verarbeitung durchführen, die zum Planen der Reservierung erforderlich ist (z. B. in Ihrer eigenen Datenbank speichern).

Sende eine einfache Antwort, um das Gespräch am Laufen zu halten. Der Nutzer erhält zusammen mit Ihrer Antwort eine minimierte Belegkarte.

So senden Sie eine erste Bestellaktualisierung:

  1. Wähle auf dem Tab Szenen deine TransactionDecision-Szene aus.
  2. Wählen Sie unter Bedingung die Bedingung aus, die das Erfolgsergebnis ORDER_ACCEPTED prüft:

    scene.slots.status == "FINAL" && session.params.TransactionDecision.transactionDecision == "ORDER_ACCEPTED"
    
  3. Aktivieren Sie für diese Bedingung Webhook aufrufen und geben Sie einen Intent-Handler-Namen wie update_order an.

  4. Fügen Sie dem Webhook-Code einen Intent-Handler hinzu, um eine anfängliche Bestellaktualisierung zu senden:

    app.handle('update_order', conv => {
      const currentTime = new Date().toISOString();
      let order = conv.session.params.TransactionDecision.order;
      conv.add(new OrderUpdate({
        'updateMask': {
          'paths': [
            'reservation.status',
            'reservation.user_visible_status_label',
            'reservation.confirmation_code'
          ]
        },
        'order': {
          'merchantOrderId': order.merchantOrderId,
          'lastUpdateTime': currentTime,
          'reservation': {
            'status': 'CONFIRMED',
            'userVisibleStatusLabel': 'Reservation confirmed',
            'confirmationCode': '123ABCDEFGXYZ',
          },
        },
        'reason': 'Reason string'
      }));
    });
    

Bestellaktualisierungen senden

Der Reservierungsstatus ändert sich im Laufe seiner Lebensdauer. Senden Sie die aktualisierten Nutzerreservierungen mit HTTP PATCH-Anfragen an die Orders API, die den Bestellstatus und die Details enthalten.

Asynchrone Anfragen an die Orders API einrichten

Anfragen zur Bestellaktualisierung an die Orders API werden durch ein Zugriffstoken autorisiert. Wenn du eine Bestellaktualisierung mit PATCH für die Orders API durchführen möchtest, lade einen JSON-Dienstkontoschlüssel herunter, der mit deinem Actions Console-Projekt verknüpft ist, und tauschen Sie den Dienstkontoschlüssel gegen ein Inhabertoken aus, das an den Authorization-Header der HTTP-Anfrage übergeben werden kann.

Führen Sie die folgenden Schritte aus, um Ihren Dienstkontoschlüssel abzurufen:

  1. Gehen Sie in der Google Cloud Console zu Menü ⋮ > APIs und Dienste > Anmeldedaten > Anmeldedaten erstellen > Dienstkontoschlüssel.
  2. Wählen Sie unter Dienstkonto die Option Neues Dienstkonto aus.
  3. Legen Sie das Dienstkonto auf service-account fest.
  4. Stellen Sie die Rolle auf Projekt > Inhaber ein.
  5. Legen Sie den Schlüsseltyp auf JSON fest.
  6. Wählen Sie Erstellen aus.
  7. Ein privater JSON-Dienstkontoschlüssel wird auf Ihren lokalen Computer heruntergeladen.

Tauschen Sie im Code für die Bestellaktualisierung mithilfe der Clientbibliothek der Google APIs und des Bereichs "https://www.googleapis.com/auth/actions.order.developer" gegen ein Inhabertoken den Dienstschlüssel ein. Installationsschritte und Beispiele finden Sie auf der GitHub-Seite der API-Clientbibliothek.

Ein Beispiel für einen Schlüsselaustausch finden Sie unter order-update.js im Node.js-Beispiel.

Bestellaktualisierungen senden

Nachdem Sie Ihren Dienstkontoschlüssel gegen ein OAuth-Inhabertoken ausgetauscht haben, senden Sie Bestellaktualisierungen als autorisierte PATCH-Anfragen an die Orders API.

URL der Orders API: PATCH https://actions.googleapis.com/v3/orders/${orderId}

Geben Sie in Ihrer Anfrage die folgenden Header an:

  • "Authorization: Bearer token" durch das OAuth-Inhabertoken, gegen das Sie Ihren Dienstkontoschlüssel ausgetauscht haben.
  • "Content-Type: application/json".

Die PATCH-Anfrage sollte einen JSON-Text im folgenden Format haben:

{ "orderUpdate": OrderUpdate }

Das Objekt OrderUpdate besteht aus den folgenden Feldern der obersten Ebene:

  • updateMask: die Felder des Auftrags, den Sie aktualisieren Legen Sie den Wert auf reservation.status, reservation.userVisibleStatusLabel fest, um den Reservierungsstatus zu aktualisieren.
  • order: Der Inhalt des Updates. Wenn Sie den Inhalt der Reservierung aktualisieren, legen Sie den Wert auf das aktualisierte Order-Objekt fest. Wenn Sie nur den Status der Reservierung aktualisieren (z. B. von "PENDING" zu "FULFILLED"), enthält das Objekt die folgenden Felder:

    • merchantOrderId: Dies ist die ID, die Sie im Order-Objekt festgelegt haben.
    • lastUpdateTime: Der Zeitstempel dieser Aktualisierung.
    • purchase: ein Objekt, das Folgendes enthält:
      • status: Der Status der Bestellung als ReservationStatus, z. B. „CONFIRMED“ oder „CANCELLED“.
      • userVisibleStatusLabel: ein für den Nutzer sichtbares Label mit Details zum Bestellstatus, z. B. „Ihre Reservierung ist bestätigt“.
  • userNotification (optional) – Ein userNotification-Objekt, das auf dem Gerät des Nutzers angezeigt werden kann, wenn dieses Update gesendet wird. Das Hinzufügen dieses Objekts garantiert jedoch nicht, dass eine Benachrichtigung auf dem Gerät des Nutzers erscheint.

Der folgende Beispielcode zeigt ein OrderUpdate-Beispiel, das den Status der Reservierungsreihenfolge in FULFILLED aktualisiert:

// Import the 'googleapis' module for authorizing the request.
const {google} = require('googleapis');
// Import the 'request-promise' module for sending an HTTP POST request.
const request = require('request-promise');
// Import the OrderUpdate class from the client library.
const {OrderUpdate} = require('@assistant/conversation');

// Import the service account key used to authorize the request.
// Replacing the string path with a path to your service account key.
// i.e. const serviceAccountKey = require('./service-account.json')

// Create a new JWT client for the Actions API using credentials
// from the service account key.
let jwtClient = new google.auth.JWT(
   serviceAccountKey.client_email,
   null,
   serviceAccountKey.private_key,
   ['https://www.googleapis.com/auth/actions.order.developer'],
   null,
);

// Authorize the client
let tokens = await jwtClient.authorize();

// Declare the ID of the order to update.
const orderId = '<UNIQUE_MERCHANT_ORDER_ID>';

// Declare order update
const orderUpdate = new OrderUpdate({
   updateMask: {
     paths: [
       'contents.lineItems.reservation.status',
       'contents.lineItems.reservation.userVisibleStatusLabel'
     ]
   },
   order: {
     merchantOrderId: orderId, // Specify the ID of the order to update
     lastUpdateTime: new Date().toISOString(),
     contents: {
       lineItems: [
         {
           reservation: {
             status: 'FULFILLED',
             userVisibleStatusLabel: 'Reservation fulfilled',
           },
         }
       ]
     },
   },
   reason: 'Reservation status was updated to fulfilled.',
});

// Set up the PATCH request header and body,
// including the authorized token and order update.
let options = {
 method: 'PATCH',
 uri: `https://actions.googleapis.com/v3/orders/${orderId}`,
 auth: {
   bearer: tokens.access_token,
 },
 body: {
   header: {
     isInSandbox: true,
   },
   orderUpdate,
 },
 json: true,
};

// Send the PATCH request to the Orders API.
try {
 await request(options);
} catch (e) {
 console.log(`Error: ${e}`);
}

Reservierungsstatus festlegen

Die ReservationStatus einer Bestellaktualisierung muss eine Beschreibung des aktuellen Status der Bestellung enthalten. Verwenden Sie im Feld order.ReservationStatus des Updates einen der folgenden Werte:

  • PENDING: Die Reservierung wurde von deiner Aktion "erstellt", erfordert jedoch eine zusätzliche Verarbeitung in deinem Back-End.
  • CONFIRMED: Die Reservierung wurde im Back-End Ihrer Terminplanung bestätigt.
  • CANCELLED: Der Nutzer hat seine Reservierung storniert.
  • FULFILLED: Die Reservierung des Nutzers wurde über den Dienst erfüllt.
  • CHANGE_REQUESTED: Der Nutzer hat eine Änderung an der Reservierung angefordert und die Änderung wird verarbeitet.
  • REJECTED: Wenn Sie die Reservierung nicht verarbeiten oder anderweitig bestätigen konnten.

Senden Sie Bestellaktualisierungen für jeden für Ihre Reservierung relevanten Status. Wenn für Ihre Reservierung beispielsweise eine manuelle Verarbeitung erforderlich ist, um die Reservierung nach ihrer Anfrage zu bestätigen, senden Sie eine PENDING-Bestellaktualisierung, bis die zusätzliche Verarbeitung abgeschlossen ist. Nicht für jede Reservierung ist jeder Statuswert erforderlich.

Projekt testen

Beim Testen deines Projekts kannst du den Sandbox-Modus in der Actions Console aktivieren, um deine Aktion zu testen, ohne eine Zahlungsmethode zu belasten. So aktivieren Sie den Sandbox-Modus:

  1. Klicken Sie in der Actions Console im Navigationsbereich auf Test.
  2. Klicke auf Einstellungen.
  3. Aktivieren Sie die Option Entwicklungs-Sandbox.

Für physische Transaktionen können Sie das Feld isInSandbox in Ihrem Beispiel auch auf true setzen. Diese Aktion entspricht dem Aktivieren der Einstellung für den Sandbox-Modus in der Actions Console. Ein Code-Snippet, in dem isInSandbox verwendet wird, findest du im Abschnitt Bestellaktualisierungen senden.

Fehlerbehebung

Falls während des Tests Probleme auftreten, lesen Sie unsere Schritte zur Fehlerbehebung für Transaktionen.