Webhook-Dienst erstellen

Der vordefinierte Agent, den Sie im letzten Schritt erstellt haben, benötigt einen Webhook. Der Einfachheit halber wird der Webhook in dieser Anleitung mit Cloud Functions gehostet. Es gibt jedoch noch viele andere Möglichkeiten, einen Webhook-Dienst zu hosten. In diesem Beispiel wird auch die Programmiersprache Go verwendet. Sie können jedoch jede von Cloud Functions unterstützte Sprache verwenden.

Funktion erstellen

Cloud Functions-Funktionen können mit der Google Cloud Console erstellt werden (Dokumentation ansehen, Konsole öffnen). So erstellen Sie eine Funktion für diese Anleitung:

  1. Der Dialogflow-Agent und die Funktion müssen sich im selben Projekt befinden. Dies ist die einfachste Möglichkeit für Dialogflow, einen sicheren Zugriff auf die Funktion zu erhalten. Wählen Sie vor dem Erstellen der Funktion Ihr Projekt in der Google Cloud Console aus.

    Zur Projektauswahl

  2. Öffnen Sie die Übersichtsseite zu Cloud Functions.

    Zur Cloud Functions-Übersicht

  3. Klicken Sie auf Funktion erstellen und legen Sie die folgenden Felder fest:

    • Umgebung: 1. Generation
    • Funktionsname: tutorial-telecommunications-webhook
    • Region: Wenn Sie eine Region für Ihren Agent angegeben haben, verwenden Sie dieselbe Region.
    • HTTP-Triggertyp: HTTP
    • URL: Klicken Sie hier auf die Schaltfläche zum Kopieren und speichern Sie den Wert. Sie benötigen diese URL zum Konfigurieren des Webhooks.
    • Authentifizierung: Authentifizierung erforderlich
    • Require HTTPS (HTTPS erforderlich): aktiviert

  4. Klicken Sie auf Speichern.

  5. Klicken Sie auf Weiter. Sie benötigen keine spezielle Laufzeit, keinen Build, keine Verbindungen oder Sicherheitseinstellungen.

  6. Legen Sie die Werte für die folgenden Felder fest:

    • Laufzeit: Wählen Sie die neueste Go-Laufzeit aus.
    • Quellcode: Inline-Editor
    • Einstiegspunkt: HandleWebhookRequest

  7. Ersetzen Sie den Code durch Folgendes: 

    package cxtwh

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strings"

	"cloud.google.com/go/spanner"
  "google.golang.org/grpc/codes"
)

// client is a Spanner client, created only once to avoid creation
// for every request.
// See: https://cloud.google.com/functions/docs/concepts/go-runtime#one-time_initialization
var client *spanner.Client

func init() {
	// If using a database, these environment variables will be set.
	pid := os.Getenv("PROJECT_ID")
	iid := os.Getenv("SPANNER_INSTANCE_ID")
	did := os.Getenv("SPANNER_DATABASE_ID")
	if pid != "" && iid != "" && did != "" {
		db := fmt.Sprintf("projects/%s/instances/%s/databases/%s",
			pid, iid, did)
		log.Printf("Creating Spanner client for %s", db)
		var err error
		// Use the background context when creating the client,
		// but use the request context for calls to the client.
		// See: https://cloud.google.com/functions/docs/concepts/go-runtime#contextcontext
		client, err = spanner.NewClient(context.Background(), db)
		if err != nil {
			log.Fatalf("spanner.NewClient: %v", err)
		}
	}
}

type fulfillmentInfo struct {
	Tag string `json:"tag"`
}

type sessionInfo struct {
	Session    string                 `json:"session"`
	Parameters map[string]interface{} `json:"parameters"`
}

type text struct {
	Text []string `json:"text"`
}

type responseMessage struct {
	Text text `json:"text"`
}

type fulfillmentResponse struct {
	Messages []responseMessage `json:"messages"`
}

// webhookRequest is used to unmarshal a WebhookRequest JSON object. Note that
// not all members need to be defined--just those that you need to process.
// As an alternative, you could use the types provided by the Dialogflow protocol buffers:
// https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/dialogflow/cx/v3#WebhookRequest
type webhookRequest struct {
	FulfillmentInfo fulfillmentInfo `json:"fulfillmentInfo"`
	SessionInfo     sessionInfo     `json:"sessionInfo"`
}

// webhookResponse is used to marshal a WebhookResponse JSON object. Note that
// not all members need to be defined--just those that you need to process.
// As an alternative, you could use the types provided by the Dialogflow protocol buffers:
// https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/dialogflow/cx/v3#WebhookResponse
type webhookResponse struct {
	FulfillmentResponse fulfillmentResponse `json:"fulfillmentResponse"`
	SessionInfo         sessionInfo         `json:"sessionInfo"`
}

// detectCustomerAnomaly handles same-named tag.
func detectCustomerAnomaly(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	// Create session parameters that are populated in the response.
	// This example hard codes values, but a real system
	// might look up this value in a database.
	p := map[string]interface{}{
		"anomaly_detect":        "false",
		"purchase":              "device protection",
		"purchase_amount":       "12.25",
		"bill_without_purchase": "54.34",
		"total_bill":            "66.59",
		"first_month":           "January 1",
	}
	// Build and return the response.
	response := webhookResponse{
		SessionInfo: sessionInfo{
			Parameters: p,
		},
	}
	return response, nil
}

// validatePhoneLine handles same-named tag.
func validatePhoneLine(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	// Create session parameters that are populated in the response.
	// This example hard codes values, but a real system
	// might look up this value in a database.
	p := map[string]interface{}{
		"domestic_coverage":   "true",
		"phone_line_verified": "true",
	}
	// Build and return the response.
	response := webhookResponse{
		SessionInfo: sessionInfo{
			Parameters: p,
		},
	}
	return response, nil
}

// cruisePlanCoverage handles same-named tag.
func cruisePlanCoverage(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	// Get the existing parameter values
	port := request.SessionInfo.Parameters["destination"].(string)
	port = strings.ToLower(port)
	// Check if the port is covered
	covered := "false"
	if client != nil {
		// A Spanner client exists, so access the database.
		// See: https://pkg.go.dev/cloud.google.com/go/spanner#ReadOnlyTransaction.ReadRow
		row, err := client.Single().ReadRow(ctx,
			"Destinations",
			spanner.Key{port},
			[]string{"Covered"})
		if err != nil {
			if spanner.ErrCode(err) == codes.NotFound {
				log.Printf("Port %s not found", port)
			} else {
				return webhookResponse{}, err
			}
		} else {
			// A row was returned, so check the value
			var c bool
			err := row.Column(0, &c)
			if err != nil {
				return webhookResponse{}, err
			}
			if c {
				covered = "true"
			}
		}
	} else {
		// No Spanner client exists, so use hardcoded list of ports.
		coveredPorts := map[string]bool{
			"anguilla": true,
			"canada":   true,
			"mexico":   true,
		}
		_, ok := coveredPorts[port]
		if ok {
			covered = "true"
		}
	}
	// Create session parameters that are populated in the response.
	// This example hard codes values, but a real system
	// might look up this value in a database.
	p := map[string]interface{}{
		"port_is_covered": covered,
	}
	// Build and return the response.
	response := webhookResponse{
		SessionInfo: sessionInfo{
			Parameters: p,
		},
	}
	return response, nil
}

// internationalCoverage handles same-named tag.
func internationalCoverage(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	// Get the existing parameter values
	destination := request.SessionInfo.Parameters["destination"].(string)
	destination = strings.ToLower(destination)
	// Hardcoded list of covered international monthly destinations
	coveredMonthly := map[string]bool{
		"anguilla":  true,
		"australia": true,
		"brazil":    true,
		"canada":    true,
		"chile":     true,
		"england":   true,
		"france":    true,
		"india":     true,
		"japan":     true,
		"mexico":    true,
		"singapore": true,
	}
	// Hardcoded list of covered international daily destinations
	coveredDaily := map[string]bool{
		"brazil":    true,
		"canada":    true,
		"chile":     true,
		"england":   true,
		"france":    true,
		"india":     true,
		"japan":     true,
		"mexico":    true,
		"singapore": true,
	}
	// Check coverage
	coverage := "neither"
	_, monthly := coveredMonthly[destination]
	_, daily := coveredDaily[destination]
	if monthly && daily {
		coverage = "both"
	} else if monthly {
		coverage = "monthly_only"
	} else if daily {
		coverage = "daily_only"
	}
	// Create session parameters that are populated in the response.
	// This example hard codes values, but a real system
	// might look up this value in a database.
	p := map[string]interface{}{
		"coverage": coverage,
	}
	// Build and return the response.
	response := webhookResponse{
		SessionInfo: sessionInfo{
			Parameters: p,
		},
	}
	return response, nil
}

// cheapestPlan handles same-named tag.
func cheapestPlan(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	// Create session parameters that are populated in the response.
	// This example hard codes values, but a real system
	// might look up this value in a database.
	p := map[string]interface{}{
		"monthly_cost":   70,
		"daily_cost":     100,
		"suggested_plan": "monthly",
	}
	// Build and return the response.
	response := webhookResponse{
		SessionInfo: sessionInfo{
			Parameters: p,
		},
	}
	return response, nil
}

// Define a type for handler functions.
type handlerFn func(ctx context.Context, request webhookRequest) (
	webhookResponse, error)

// Create a map from tag to handler function.
var handlers map[string]handlerFn = map[string]handlerFn{
	"detectCustomerAnomaly": detectCustomerAnomaly,
	"validatePhoneLine":     validatePhoneLine,
	"cruisePlanCoverage":    cruisePlanCoverage,
	"internationalCoverage": internationalCoverage,
	"cheapestPlan":          cheapestPlan,
}

// handleError handles internal errors.
func handleError(w http.ResponseWriter, err error) {
	log.Printf("ERROR: %v", err)
	http.Error(w,
		fmt.Sprintf("ERROR: %v", err),
		http.StatusInternalServerError)
}

// HandleWebhookRequest handles WebhookRequest and sends the WebhookResponse.
func HandleWebhookRequest(w http.ResponseWriter, r *http.Request) {
	var request webhookRequest
	var response webhookResponse
	var err error

	// Read input JSON
	if err = json.NewDecoder(r.Body).Decode(&request); err != nil {
		handleError(w, err)
		return
	}
	log.Printf("Request: %+v", request)

	// Get the tag from the request, and call the corresponding
	// function that handles that tag.
	tag := request.FulfillmentInfo.Tag
	if fn, ok := handlers[tag]; ok {
		response, err = fn(r.Context(), request)
	} else {
		err = fmt.Errorf("Unknown tag: %s", tag)
	}
	if err != nil {
		handleError(w, err)
		return
	}
	log.Printf("Response: %+v", response)

	// Send response
	if err = json.NewEncoder(w).Encode(&response); err != nil {
		handleError(w, err)
		return
	}
}

  8. Klicken Sie auf Bereitstellen.

  9. Warten Sie, bis die Statusanzeige anzeigt, dass die Funktion erfolgreich bereitgestellt wurde. Während Sie warten, sehen Sie sich den gerade bereitgestellten Code an.

Webhook für Ihren Agent konfigurieren

Da der Webhook nun als Dienst vorhanden ist, verknüpfen Sie ihn mit Ihrem Agent. So konfigurieren Sie den Webhook für Ihren Agent:

  1. Öffnen Sie die Dialogflow CX Console.
  2. Wählen Sie Ihr Google Cloud-Projekt aus.
  3. Wählen Sie den Agent aus.
  4. Wählen Sie den Tab Verwalten.
  5. Klicken Sie auf Webhooks.
  6. Klicken Sie auf den vorhandenen Webhook, der vom vordefinierten Agent erstellt wurde.
  7. Aktualisieren Sie die Webhook-URL in die Webhook-URL, die Sie beim Erstellen der Funktion gespeichert haben.
  8. Legen Sie als Subtyp „Standard“ fest.
  9. Klicken Sie auf Speichern.

Agent ausprobieren

Der Agent kann jetzt ausprobiert werden. Klicken Sie auf die Schaltfläche Agent testen, um den Simulator zu öffnen. Versuchen Sie, die folgende Unterhaltung mit dem Agent zu führen:

Unterhaltungsrunde Sie Agent
1 Guten Tag, Hallo! Ich bin der virtuelle Telekommunikationsagent. Ich kann Ihnen dabei helfen, Fragen zur Abrechnung und Planung zu lösen, Fehler zu beheben und Reise- und Kreuzfahrttarife hinzuzufügen. Wie kann ich Ihnen helfen?
2 Ich möchte einen Kreuzfahrttarif hinzufügen Lass mich mal nachsehen. Wie lautet Ihre Telefonnummer bei uns?
3 123-123-1234 Wie viele Tage dauert Ihre Kreuzfahrt?
4 7 Option 1 umfasst Spracheingabe und Text. Es kostet [XX] $ pro Tag. Weitere Informationen findest du hier: [URL]. Option 2 umfasst Gespräche, Text und Daten. Es kostet [XX] $ pro Tag. Weitere Informationen findest du hier: [URL]. Welchen Kreuzfahrttarif möchten Sie hinzufügen?
5 Option 1 Alles klar. Ich habe diesen Plan deinem Konto hinzugefügt. Während einer Kreuzfahrt ist eventuell auch eine Abdeckung an Land erforderlich. An welchem Port möchten Sie anhalten?
6 Mexiko Und wie viele Tage verbringst du dort?
7 3 Außerdem haben wir gute Nachrichten: In Mexiko ist die Übertragung an Land kostenlos. Das war's! Kann ich sonst noch etwas für Sie tun?

Diese Unterhaltung wurde vom Ablauf Cruise Plan verwaltet.

In Unterhaltungsrunde 6 haben Sie „Mexiko“ als Zielport angegeben. Der Zielport und die Anzahl der vorhandenen Tage werden als die Formularparameter destination und trip_duration der Seite Collect Port erfasst. Suchen Sie in Ihrem Agent nach diesen Parameterdefinitionen.

Screenshot der Seite „Collect Port“ in der Dialogflow-Gruppe

Auf der Seite Collect Port gibt es eine Bedingungsroute für das Ausfüllen des Formulars: $page.params.status = "FINAL". Nachdem die beiden Formularparameter angegeben wurden, wird diese Route aufgerufen. Über diese Route wird der Webhook aufgerufen und das Tag cruisePlanCoverage für den Webhook bereitgestellt. Wenn Sie den obigen Webhook-Code untersuchen, stellen Sie fest, dass dieses Tag den Aufruf derselben benannten Funktion auslöst.

Diese Funktion bestimmt, ob das angegebene Ziel im Tarif enthalten ist. Die Funktion prüft, ob bestimmte Umgebungsvariablen mit Informationen zum Herstellen einer Verbindung zur Datenbank festgelegt sind. Wenn diese Umgebungsvariablen nicht festgelegt sind, verwendet die Funktion eine hartcodierte Liste von Zielen. In den nächsten Schritten ändern Sie die Umgebung für die Funktion so, dass sie Daten aus einer Datenbank abruft, um die Tarifabdeckung für Ziele zu validieren.

Fehlerbehebung

Der Webhook-Code enthält Logging-Anweisungen. Wenn Probleme auftreten, können Sie versuchen, die Logs für Ihre Funktion aufzurufen.

Weitere Informationen

Weitere Informationen zu den oben genannten Schritten finden Sie hier:

Zurück
Vordefinierten Agent erstellen
Weiter
Datenbank abfragen