Olo

Olo ist eine führende offene SaaS-Plattform für Restaurants, die Gastfreundschaft an jedem Touchpoint ermöglicht.

Durch die Integration von Olo und Braze können Sie:

• Nutzerprofile in Braze aktualisieren, damit sie mit den Olo-Nutzerprofilen übereinstimmen
• Die richtigen nächstbesten Nachrichten von Braze basierend auf Olo-Events senden

Voraussetzungen

Ein Webhook ist eine Möglichkeit für Olo, ereignisgesteuerte Informationen über Nutzer:innen und deren Aktionen an Braze zu senden, einschließlich Events wie „Bestellung aufgegeben“, „Gast-Opt-in“, „Bestellung abgeholt“ und mehr. Der Olo-Webhook stellt Braze das Event in der Regel innerhalb von Sekunden nach Ausführung der Aktion zu.

Haftungsausschluss

In Olo sind Sie auf einen Webhook pro Umgebung für jede genehmigte Marke beschränkt, die alle an dieselbe Ziel-URL gesendet werden. Verschiedene Marken können unterschiedliche URLs haben, aber Events derselben Marke müssen eine gemeinsame URL haben. In Braze bedeutet dies, dass Sie nur eine Transformation für die Verwendung mit Olo erstellen können.

Um mehrere Olo-Events innerhalb dieser einzigen Transformation zu verarbeiten, suchen Sie in jedem Webhook nach dem X-Olo-Event-Type-Header. Dieser Header ermöglicht es Ihnen, verschiedene Olo-Events bedingt zu verarbeiten.

Integration

1. Schritt: Braze-Datentransformation einrichten, um das Test-Event von Olo zu akzeptieren

Gehen Sie im Braze Dashboard zu Dateneinstellungen > Datenumwandlung.

Wählen Sie Transformation erstellen, um Ihre Transformation zu benennen, und wählen Sie dann Ihre Bearbeitungserfahrung.

Wählen Sie Template verwenden, um eine Template-Bibliothek zu durchsuchen, die auch Anwendungsfälle der Datentransformation enthält. Oder wählen Sie Von Grund auf neu, um eine Standard-Codevorlage zu laden.

Wenn Sie bei Null anfangen, wählen Sie ein Ziel für Ihre Transformation. Sie können trotzdem eine Codevorlage aus der Vorlagenbibliothek einfügen.

Hinweis

Möchten Sie weitere Vorlagen oder Ziele anfordern? Ziehen Sie in Erwägung, eine Produktbewertung zu hinterlassen.

Nachdem Sie Ihre Transformation erstellt haben, sehen Sie die Detailansicht der Transformation. Hier können Sie unter Webhook-Details den zuletzt empfangenen Webhook für diese Transformation einsehen und unter Transformationscode ein Feld für die Eingabe Ihres Transformationscodes.

Erfassen Sie Ihre Webhook-URL zur Verwendung im nächsten Schritt.

2. Schritt: Olo-Webhooks einrichten

Verwenden Sie das Self-Service-Webhooks-Tool im Olo-Dashboard, um Webhooks einzurichten, die an Ihre Datentransformation gesendet werden.

1. Wählen Sie, welche Events an Braze gesendet werden sollen.
2. Konfigurieren Sie die Ziel-URL. Dies ist die in Schritt 1 erstellte URL für die Datentransformation.

Hinweis

OAuth und das gemeinsame Geheimnis des X-Olo-Signature-Headers werden für die Transformation nicht benötigt.

3. Überprüfen Sie, ob der Webhook richtig konfiguriert ist, indem Sie ein Test-Event an Ihre Datentransformation senden. Nur Nutzer:innen des Olo-Dashboards mit der Berechtigung für Entwickler:innen-Tools können Test-Events senden.

Olo benötigt eine erfolgreiche Antwort vom Test-Event-Webhook, bevor Sie die Konfiguration des Olo-Webhooks abschließen können.

3. Schritt: Transformationscode schreiben, um die von Ihnen gewählten Olo-Events zu akzeptieren

In diesem Schritt transformieren Sie die Webhook-Nutzlast, die von der Quellplattform gesendet wird, in einen Rückgabewert als JavaScript-Objekt.

1. Senden Sie eine Anfrage an Ihre URL für die Datentransformation mit einer Beispiel-Nutzlast eines Olo-Events, das Sie unterstützen möchten. Siehe Format des Anfragekörpers für Hilfe bei der Formatierung Ihrer Anfrage.
2. Aktualisieren Sie Ihre Datentransformation und vergewissern Sie sich, dass Sie die Beispiel-Nutzlast des Events in den Webhook-Details sehen können.
3. Aktualisieren Sie Ihren Datentransformationscode, um die von Ihnen gewählten Olo-Events zu unterstützen.
4. Klicken Sie auf Validate, um eine Vorschau der Ausgabe Ihres Codes zu erhalten und zu prüfen, ob es sich um eine akzeptable /users/track-Anfrage handelt.
5. Speichern und aktivieren Sie Ihre Datentransformation.

Format des Anfragekörpers

Dieser Rückgabewert muss dem Format des /users/track-Anfragekörpers von Braze entsprechen:

• Der Transformationscode wird in der Programmiersprache JavaScript akzeptiert. Jeder Standard-JavaScript-Kontrollfluss, wie z. B. die if/else-Logik, wird unterstützt.
• Der Transformationscode greift über die Nutzlastvariable auf den Körper der Webhook-Anfrage zu. Diese Variable ist ein Objekt, das durch das Parsen des JSON-Körpers der Anfrage erstellt wird.
• Alle Features, die in unserem /users/track-Endpunkt unterstützt werden, werden unterstützt, einschließlich:
  • Nutzerattribut-Objekte, Event-Objekte und Kauf-Objekte
  • Verschachtelte Attribute und verschachtelte Event-Eigenschaften angepasster Events
  • Updates für Abo-Gruppen
  • E-Mail-Adresse als Bezeichner

Beispiel-Datentransformationen für Olo-Webhooks

Dieser Abschnitt enthält Beispiel-Templates, die als Ausgangspunkt verwendet werden können. Sie können auch von Grund auf neu beginnen oder bestimmte Komponenten nach Belieben löschen.

In jedem Template definiert der Code eine Variable, brazecall, um eine /users/track-Anfrage zu erstellen.

Nachdem die /users/track-Anfrage brazecall zugewiesen wurde, geben Sie explizit brazecall zurück, um eine Ausgabe zu erstellen.

Transformation eines einzelnen Events

Wenn Sie nur ein einziges Olo-Event unterstützen möchten, brauchen Sie den X-Olo-Event-Type-Header nicht zu verwenden, um die Nutzlast der /users/track-Anfrage bedingt zu erstellen. Zum Beispiel das Protokollieren eines Kauf-Events oder eines angepassten Events im Nutzerprofil, wenn ein Olo-Order-Placed-Webhook an Braze gesendet wird.

Jedes Produkt als Kauf protokollieren

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// iterate through the items included within the order

const purchases = payload.items.map((item) => {
 return {
   external_id: payload.customer.customerId.toString(),
   product_id: item.productId.toString(),
   currency: 'USD',
   price: item.sellingPrice,
   time: new Date().toISOString(),
   quantity: item.quantity,
   properties: {
     customValues: item.customValues
   }
 };
});

// log a purchase per item in the order

let brazecall = {
 "purchases": purchases
};

return brazecall;

Protokollieren eines angepassten Events

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// log an event “Order Placed” to the profile that includes all items in the order as event properties.

let brazecall = {
"events": [
   {
     "external_id": payload.customer.customerId.toString(),
     "_update_existing_only": false,
     "name": "Order Placed",
     "time": new Date().toISOString(),
     "properties": {
       "Delivery Method": payload.deliveryMethod,
       "Items": payload.items,
       "Total": payload.totals.total,
       "Location": payload.location.name
     }
   }
 ]
};

return brazecall;

Multi-Event-Transformation

Olo sendet den Event-Typ im X-Olo-Event-Type-Header jedes Webhooks. Um mehrere Olo-Webhook-Events innerhalb einer einzigen Transformation zu unterstützen, verwenden Sie bedingte Logik, um die Webhook-Nutzlast basierend auf dem Wert dieses Header-Typs zu transformieren.

Im folgenden Transformationsbeispiel erstellt unser JavaScript eine bestimmte Nutzlast für die Events UserSignedUp und OrderPlaced. Zusätzlich behandelt eine else-Bedingung eine Nutzlast für alle Olo-Events, die ohne den X-Olo-Event-Type-Header UserSignedUp und OrderPlaced an Braze gesendet werden.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
// captures the value within the X-Olo-Event-Type header for use in the conditional logic

let event_type = headers["X-Olo-Event-Type"];

// defines a variable 'brazecall' that will hold the request payload for the /users/track request

let brazecall;

// if the X-Olo-Event-Type header is 'UserSignedUp', define a variable for the different subscription statuses that could be included within the Olo event payload

if (event_type == "UserSignedUp") {
	let emailSubscribe;
	let emailSubscriptionGroup;
	let smsSubscriptionGroup;


// determine if the user has opted into marketing emails


	if (payload.allowEmail) {
		emailSubscribe = "opted_in";
		emailSubscriptionGroup = "subscribed";
	} else {
		emailSubscribe = "unsubscribed";
		emailSubscriptionGroup = "unsubscribed";
	}


	// determine if the user has opted into SMS


	if (payload.allowMarketingSms) {
		smsSubscriptionGroup = "subscribed";
	} else {
		smsSubscriptionGroup = "unsubscribed";
	}

	// build the /users/track request and pass in the appropriate subscription statuses


	brazecall = {
		"attributes": [{
			"external_id": payload.id.toString(),
			"_update_existing_only": false,
			"email": payload.emailAddress,
			"first_name": payload.firstName,
			"last_name": payload.lastName,
			"email_subscribe": emailSubscribe,
			"phone": payload.contactNumber,
			"subscription_groups": [{
					"subscription_group_id": "57e5307f-9084-490d-9d6d-8244dc919a48",
					"subscription_state": emailSubscriptionGroup
				},
				{
					"subscription_group_id": "6440ba26-86ea-47db-a935-6647941dc78b",
					"subscription_state": smsSubscriptionGroup
				}
			]
		}]
	}; // if the X-Olo-Event-Type header is 'OrderPlaced', build the /users/track request to log an event to the user profile
} else if (event_type == "OrderPlaced") {
	brazecall = {
		"events": [{
			"external_id": payload.customer.customerId.toString(),
			"_update_existing_only": false,
			"name": "Order Placed",
			"time": new Date().toISOString(),
			"properties": {
				"Delivery Method": payload.deliveryMethod,
				"Items": payload.items,
				"Total": payload.totals.total,
				"Location": payload.location.name
			}
		}]
	};
} else { // if the X-Olo-Event-Type header is anything else, build the /users/track request to log an event to the user profile
	brazecall = {
		"events": [{
			"external_id": payload.customer.customerId.toString(),
			"_update_existing_only": true,
			"name": "Another Event",
			"time": new Date().toISOString()
		}]

	};
}

// return `brazecall` to create an output.

return brazecall;

4. Schritt: Olo-Webhook veröffentlichen

Nachdem Sie Ihre Datentransformation in Braze aktiviert haben, verwenden Sie das Self-Service-Webhooks-Tool im Olo-Dashboard, um Ihren Webhook zu veröffentlichen. Wenn der Webhook veröffentlicht wird, beginnt die Datentransformation mit dem Empfang von Olo-Webhook-Event-Nachrichten.

Wissenswertes

Wiederholungsversuche

Olo wiederholt Webhook-Aufrufe, die zu einem HTTP-Antwort-Statuscode von 429 - Too Many Requests oder im Bereich 5xx führen (z. B. aufgrund eines Gateway-Timeouts oder eines Server-Fehlers), innerhalb von 24 Stunden bis zu 50 Mal, bevor die Anfrage verworfen wird.

Zustellung mindestens einmal

Wenn ein Webhook-Aufruf zu einem HTTP-Antwort-Statuscode von 429 - Too Many Requests oder im Bereich 5xx führt (z. B. aufgrund eines Gateway-Timeouts oder eines Server-Fehlers), versucht Olo die Nachricht innerhalb von 24 Stunden bis zu 50 Mal erneut zu senden, bevor es aufgibt.

Webhooks können daher mehrfach von Abonnent:innen empfangen werden. Es liegt in der Verantwortung der Abonnent:innen, Duplikate zu ignorieren, indem sie den X-Olo-Message-Id-Header überprüfen.