Die Transactions API wird am 3. Mai 2023 eingestellt, bevor die Konversationsaktionen am 13. Juni 2023 eingestellt werden. Weitere Informationen finden Sie unter Einstellung von Konversationsaktionen.

Diese Seite wurde von der Cloud Translation API übersetzt.

Build-Reservierungen

Dieser Leitfaden führt Sie durch die Entwicklung eines Actions-Projekts. das die Orders API für Reservierungen nutzt.

Transaktionsablauf

Wenn in Ihrem Actions-Projekt Reservierungen verarbeitet werden, verwendet den folgenden Ablauf:

Transaktionsanforderungen validieren (optional): Transaktionen verwenden zu Beginn des Gesprächs helfen, sicherzustellen, dass die der Nutzer in der Lage ist, eine Transaktion durchzuführen.
Erstellen der Bestellung: Gehen Sie den Nutzer durch eine „cartmontage“ in dem sie die Details ihrer Reservierung angeben.
Bestellung vorschlagen: Sobald der „Einkaufswagen“ abgeschlossen ist, schlagen Sie die Reservierung vor, bis damit diese die Richtigkeit bestätigen können. Wenn die Reservierung bestätigt wird, erhalten Sie eine Antwort mit Reservierungsdetails.
Bestellung abschließen und Beleg senden: Sobald die Bestellung bestätigt wurde, aktualisieren Sie und eine Quittung an den Nutzer senden.
Updates zu Bestellungen senden: Während der Laufzeit der Reservierung Aktualisierungen des Reservierungsstatus des Nutzers durch Senden von PATCH-Anfragen an den Orders API

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

Für Aktionen, bei denen das Transaktionen und Orders API. Die Überprüfung der Aktionen kann bis zu sechs Wochen dauern Transaktionen. Berücksichtigen Sie diese Zeit bei der Planung Ihres Veröffentlichungszeitplans. Um den Überprüfungsprozess zu erleichtern, sollten Sie sicherstellen, dass Sie die Richtlinien für Transaktionen bevor du deine Aktion zur Überprüfung einreichst.

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

Australien
Brasilien
Kanada
Indonesien

Japan
Mexiko
Katar
Russland

Singapur
Schweiz
Thailand
Türkei
Vereinigtes Königreich
USA

Projekt erstellen

Ein ausführliches Beispiel für Transaktionsanfragen finden Sie in unseren Transaktionen Beispiel in Node.js

Einrichtung

Beim Erstellen der Aktion musst du angeben, dass du Transaktionen durchführen möchtest. in der Actions Console.

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

Erstellen Sie ein neues Projekt oder importieren Sie ein vorhandenes Projekt.
Gehen Sie zu Bereitstellen > Verzeichnisinformationen.
Unter Weitere Informationen > Transaktionen > aktiviere das Kontrollkästchen „Führe deine Aktionen aus“ die Transactions API für Transaktionen mit physischen Waren verwenden?“.

Transaktionsanforderungen validieren (optional)

Sobald der Nutzer angegeben hat, dass er eine Reservierung vornehmen möchte, solltest du prüfen, eine Reservierung anfordern können. Wenn deine Aktion beispielsweise aufgerufen wird, fragen Sie: "Möchten Sie einen Platz reservieren?" Wenn die nutzende Person „Ja“ sagt, sollten Sie damit er fortfahren kann und dass er die Möglichkeit hat, Einstellungen zu korrigieren. sodass er die Transaktion nicht fortsetzen kann. Dazu müssen Sie Übergang zu einer Szene, in der eine Prüfung der Transaktionsanforderungen durchgeführt wird.

Szene mit Prüfung der Transaktionsanforderungen erstellen

Fügen Sie auf dem Tab Szenen eine neue Szene mit dem Namen TransactionRequirementsCheck
Klicken Sie unter Slot-Füllung auf +, um eine neue Anzeigenfläche hinzuzufügen.
Wählen Sie unter Typ auswählen die Option actions.type.TransactionRequirementsCheckResult aus. als Slottyp aus.
Geben Sie im Feld für den Slotnamen den Namen TransactionRequirementsCheck für die Anzeigenfläche ein.
Klicken Sie das Kästchen Writeback für Slot-Wert anpassen an (standardmäßig aktiviert).
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 erfolgreich festgelegt. und Sie können mit dem Aufbau der Bestellung für die Nutzenden fortfahren.
Wenn eine oder mehrere Anforderungen nicht erfüllt werden können, lautet der Sitzungsparameter mit einer Fehlerbedingung festgelegt. In diesem Fall sollten Sie das Gespräch oder das Gespräch 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 über eine reine Sprachoberfläche läuft, wird eine Übergabe auf dem Smartphone des Nutzers initiiert werden.

Ergebnis der Prüfung der Transaktionsanforderungen

Wähle auf dem Tab Szenen die neu erstellte TransactionRequirementsCheck Szene.
Klicken Sie unter Bedingung auf +, um eine neue Bedingung hinzuzufügen.

Geben Sie im Textfeld die folgende Bedingungssyntax ein, um zu prüfen, ob Erfolgsbedingung:

scene.slots.status == "FINAL" && session.params.TransactionRequirementsCheck.resultType == "CAN_TRANSACT"

Bewegen Sie den Mauszeiger auf die gerade hinzugefügte Bedingung und klicken Sie auf den Aufwärtspfeil um es vor if scene.slots.status == "FINAL" zu platzieren.
Sie können Prompts senden aktivieren und den Nutzer mit einer einfachen Aufforderung darüber informieren. können sie eine Transaktion durchführen:
```
candidates:
  - first_simple:
      variants:
        - speech: >-
            Looks like you're good to go!.
```
Wählen Sie unter Übergang eine andere Szene aus, damit der Nutzer fortfahren kann. und mit der Transaktion fortfahren.
Wählen Sie die Bedingung else if scene.slots.status == "FINAL" aus.
Sie können Prompts senden aktivieren und den Nutzer mit einer einfachen Aufforderung darüber informieren. keine Transaktion durchführen kann:
```
candidates:
  - first_simple:
      variants:
        - speech: Transaction requirements check failed.
```
Wählen Sie unter Übergang die Option Unterhaltung beenden aus, um sie zu beenden. Ein Nutzer kann keine Transaktionen durchführen.

Auftrag erstellen

Sobald Sie die benötigten Informationen haben, erstellen Sie einen Warenkorb Montage“ die den Nutzer dabei unterstützt, eine Reservierung vorzunehmen. Jeden Die Aktion unterscheidet sich je nach Bedarf des .

Bei einer einfachen Einkaufswagen-Montage wählt ein Nutzer Optionen aus einer Liste aus, um sie hinzuzufügen. Sie können das Gespräch jedoch so gestalten, User Experience aus. Erstellen Sie zum Beispiel eine Warenkorb-Montageumgebung, die die Nutzer können mit einer einfachen Ja-oder-Nein-Frage eine monatliche Reservierung vornehmen. Sie können dem Nutzer auch ein Karussell oder eine Listenkarte Reservierungen.

Wir empfehlen Rich-Media-Antworten, um die Optionen der Nutzenden visuell zu präsentieren, aber auch das Gespräch so zu gestalten, können Nutzende ihren Warenkorb nur mit ihrer Stimme zusammenstellen. Einige Best Practices und Beispiele für den Zusammenbau von Einkaufswagen finden Sie in den Designrichtlinien.

Auftrag erstellen

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

Die Datei Order muss mindestens Folgendes enthalten:

buyerInfo: Informationen zu dem Nutzer, der den Kauf vornimmt.
transactionMerchant: Informationen zum Händler, der die Bestellung durchgeführt hat.
contents: Der tatsächliche Inhalt der Bestellung, angegeben als lineItems.

Weitere Informationen finden Sie im Order. Antwortdokumentation zum Erstellen Ihres Einkaufswagens. Möglicherweise müssen Sie je nach Reservierung verschiedene Felder.

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'
 };

Optionen für Erstellungsreihenfolge und Präsentation

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

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

Bestelldaten im Sitzungsparameter speichern

Speichern Sie die Bestelldaten aus der Auftragsausführung in einem Sitzungsparameter. Die Reihenfolge -Objekt wird in allen Szenen in derselben Sitzung verwendet.

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

Bestellung vorschlagen

Nachdem Sie einen Reservierungsauftrag erstellt haben, müssen Sie ihn dem Nutzer bestätigen oder ablehnen. Wechseln Sie dazu zu einer Szene, in der eine Transaktion ausgeführt wird. zu entscheiden.

Transaktionsentscheidungsszene erstellen

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

Um einen TransactionDecisionValue-Slot zu füllen, initiiert Assistant eine integrierte Websitevariante, in der das von Ihnen übergebene Order-Element direkt in eine „Warenkorbvorschau“-Karte. Der Nutzer kann „Reservierung planen“ sagen, die Transaktion ablehnen oder fordern Sie die Änderung der Reservierungsdetails an.

Der Nutzer kann zu diesem Zeitpunkt auch Änderungen an der Bestellung anfordern. In diesem Fall sollte sicherstellen, dass die Auftragsausführung Anfragen für Bestelländerungen bearbeiten kann, den Einkaufswagen zusammenbauen.

Ergebnis der Transaktionsentscheidung verarbeiten

Wenn eine TransactionDecisionValue-Fläche gefüllt ist, wird die Antwort des Nutzers auf das Transaktionsentscheidung wird 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:

Wählen Sie auf dem Tab Szenen die neu erstellte Szene TransactionDecision aus.
Klicken Sie unter Bedingung auf +, um eine neue Bedingung hinzuzufügen.

Geben Sie im Textfeld die folgende Bedingungssyntax ein, um zu prüfen, ob Erfolgsbedingung:

scene.slots.status == "FINAL" && session.params.TransactionDecision.transactionDecision == "ORDER_ACCEPTED"

Bewegen Sie den Mauszeiger auf die gerade hinzugefügte Bedingung und klicken Sie auf den Aufwärtspfeil um es vor if scene.slots.status == "FINAL" zu platzieren.

Sie können Prompts senden aktivieren und den Nutzer mit einer einfachen Aufforderung darüber informieren. ihre Reservierung abgeschlossen ist:

candidates:
  - first_simple:
      variants:
        - speech: >-
            Transaction completed! Your reservation
            $session.params.TransactionDecision.order.merchantOrderId is all
            set!

Wählen Sie unter Übergang die Option Unterhaltung beenden aus.
Klicken Sie unter Bedingung auf +, um eine neue Bedingung hinzuzufügen.

Geben Sie im Textfeld die folgende Bedingungssyntax ein, um zu prüfen, ob Fehlerbedingungen:

  scene.slots.status == "FINAL" && session.params.TransactionDecision.transactionDecision == "ORDER_REJECTED"

Bewegen Sie den Mauszeiger auf die gerade hinzugefügte Bedingung und klicken Sie auf den Aufwärtspfeil um es vor if scene.slots.status == "FINAL" zu platzieren.

Aktivieren Sie Prompts senden und geben Sie eine einfache Aufforderung an den Nutzer weiter, Bestellung wurde abgelehnt:

candidates:
  - first_simple:
      variants:
        - speech: Looks like you don't want to set up a reservation. Goodbye.

Wählen Sie unter Übergang die Option Unterhaltung beenden aus.
Wählen Sie die Bedingung else if scene.slots.status == "FINAL" aus.

Sie können Prompts senden aktivieren und den Nutzer mit einer einfachen Aufforderung darüber informieren. keine Transaktion durchführen kann:

candidates:
  - first_simple:
      variants:
        - speech: >-
            Transaction failed with status
            $session.params.TransactionDecision.transactionDecision

Wählen Sie unter Übergang die Option Unterhaltung beenden aus, um sie zu beenden. Ein Nutzer kann keine Transaktionen durchführen.

Reservierung abschließen und Beleg senden

Wenn der TransactionDecisionValue-Slot das Ergebnis ORDER_ACCEPTED zurückgibt, müssen Sie sofort alle erforderlichen Verarbeitungsschritte ausführen, (z. B. in Ihrer eigenen Datenbank speichern).

Senden Sie eine einfache Antwort, um das Gespräch am Laufen zu halten. Der Nutzer erhält eine „Minimierte Belegkarte“ zusammen mit Ihrer Antwort.

So senden Sie eine erste Bestellaktualisierung:

Wählen Sie auf dem Tab Szenen die Szene TransactionDecision aus.

Wählen Sie unter Bedingung die Bedingung aus, die auf das Erfolgsergebnis geprüft wird. ORDER_ACCEPTED:

scene.slots.status == "FINAL" && session.params.TransactionDecision.transactionDecision == "ORDER_ACCEPTED"

Aktivieren Sie für diese Bedingung die Option Call your webhook (Webhook aufrufen) und geben Sie einen Intent an. Handler-Name, z. B. update_order.

Fügen Sie dem Webhook-Code einen Intent-Handler hinzu, um ein anfängliches Bestellupdate 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'
  }));
});

Updates zu Bestellungen senden

Der Reservierungsstatus ändert sich im Laufe seiner Lebensdauer. An den Nutzer senden Aktualisierungen von Reservierungsbestellungen mit HTTP-PATCH-Anfragen an die Orders API, die Folgendes enthalten: Bestellstatus und -details.

Asynchrone Anfragen an die Orders API einrichten

Anfragen zur Aktualisierung von Bestellungen an die Orders API sind durch einen Zugriff autorisiert Token. Lade eine JSON-Datei herunter, um ein Update für eine Bestellung per PATCH in die Orders API aufzunehmen. Dienstkontoschlüssel, der mit Ihrem Actions Console-Projekt verknüpft ist, und tauschen Sie dann Den Dienstkontoschlüssel für ein Inhabertoken, das an die Authorization-Header der HTTP-Anfrage.

So rufen Sie den Dienstkontoschlüssel ab:

Führen Sie in der Google Cloud Console folgende Schritte aus: Gehe zum Menü Ђ > APIs und Dienste > Anmeldedaten > Anmeldedaten erstellen > Dienstkontoschlüssel.
Wählen Sie unter Dienstkonto die Option Neues Dienstkonto aus.
Legen Sie für das Dienstkonto service-account fest.
Legen Sie die Rolle auf Projekt > Inhaber.
Legen Sie den Schlüsseltyp auf JSON fest.
Wählen Sie Erstellen aus.
Ein privater JSON-Dienstkontoschlüssel wird auf Ihren lokalen Computer heruntergeladen.

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

Verweisen Sie in unserem Node.js-Beispiel auf order-update.js. ein Beispiel für einen Schlüsselaustausch.

Updates zu Bestellungen senden

Nachdem du deinen Dienstkontoschlüssel gegen ein OAuth-Inhabertoken ausgetauscht hast, Bestellaktualisierungen als autorisierte PATCH-Anfragen an die Orders API.

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

Geben Sie in Ihrer Anfrage die folgenden Header an:

"Authorization: Bearer token" durch das OAuth-Inhabertoken für den Sie Ihren Dienstkontoschlüssel ausgetauscht haben.
"Content-Type: application/json".

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

{ "orderUpdate": OrderUpdate }

Die OrderUpdate besteht aus den folgenden Feldern der obersten Ebene:

updateMask: die Felder des Auftrags, den Sie aktualisieren So aktualisieren Sie die Reservierungsstatus, Legen Sie den Wert auf reservation.status, reservation.userVisibleStatusLabel fest.
order: Der Inhalt der Aktualisierung. Wenn Sie die der Reservierung enthält, legen Sie den Wert auf das aktualisierte Objekt Order fest. Wenn Sie nur den Status der Reservierung aktualisieren (z. B. von "PENDING" bis "FULFILLED"), enthält das Objekt den Parameter folgenden Feldern:
- merchantOrderId: Dies ist die ID, die Sie im Objekt Order festgelegt haben.
- lastUpdateTime: Der Zeitstempel dieser Aktualisierung.
- purchase – ein Objekt, das Folgendes enthält: <ph type="x-smartling-placeholder">
  - status: der Status der Bestellung als ReservationStatus z. B. "CONFIRMED" oder "CANCELLED".
  - userVisibleStatusLabel – ein für den Nutzer sichtbares Label mit Details zu Bestellstatus, z. B. „Ihre Reservierung wurde bestätigt“.
userNotification (optional): A userNotification Objekt, das auf dem Gerät des Nutzers angezeigt werden kann, wenn dieses Update gesendet wird. Hinweis dass die Angabe dieses Objekts nicht garantiert, dass auf dem das Gerät der Nutzenden.

Der folgende Beispielcode zeigt ein OrderUpdate-Beispiel, mit dem die Status des Reservierungsauftrags auf FULFILLED:

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

ReservationStatus eines Bestellupdates muss den aktuellen Status der Bestellung beschreiben. Im order.ReservationStatus deines Updates einen der folgenden Werte verwenden:

PENDING: Die Reservierung wurde „erstellt“. Aktion ausgeführt. Er muss jedoch zusätzliche Verarbeitung im Back-End.
CONFIRMED: Die Reservierung wurde im Backend für die Planung bestätigt.
CANCELLED: Der Nutzer hat seine Reservierung storniert.
FULFILLED: Die Reservierung des Nutzers wurde vom Dienst erfüllt.
CHANGE_REQUESTED: Der Nutzer hat eine Reservierungsänderung angefordert, die: verarbeitet wird.
REJECTED – wenn Sie nicht in der Lage waren oder anderweitig verarbeitet werden konnten um die Reservierung zu bestätigen.

Senden Sie für jeden Status, der für Ihr Reservierung. Wenn Ihre Reservierung z. B. eine manuelle Verarbeitung erfordert, die Reservierung nach ihrer Anfrage bestätigen, eine Aktualisierung der Bestellung über PENDING senden bis dass eine zusätzliche Verarbeitung erfolgt. Nicht jede Reservierung erfordert jeden Statuswert.

Projekt testen

Wenn du dein Projekt testest, 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:

Klicken Sie in der Actions Console im Navigationsbereich auf Testen.
Klicken Sie auf Einstellungen.
Aktivieren Sie die Option Entwickler-Sandbox.

Bei physischen Transaktionen können Sie auch das Feld isInSandbox auf true setzen, Ihre Stichprobe. Diese Aktion entspricht der Aktivierung der Einstellung für den Sandbox-Modus in in der Actions Console. Ein Code-Snippet, das isInSandbox verwendet, finden Sie in der Bereich Aktuelle Informationen zur Bestellung senden.

Fehlerbehebung

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