Webhook-Dienst erstellen

Für den vordefinierten Agent, den Sie im letzten Schritt erstellt haben, ist ein webhook. Cloud Run-Funktionen werden aufgrund ihrer Einfachheit in diesem Tutorial zum Hosten des Webhooks verwendet. Es gibt aber noch viele andere Möglichkeiten, einen Webhook-Dienst zu hosten. In diesem Beispiel wird auch die Programmiersprache Go verwendet, Sie können aber von Cloud Run-Funktionen unterstützte Sprache.

Funktion erstellen

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

  1. Es ist wichtig, dass Ihr Dialogflow-Agent und die Funktion sich beide im selben Projekt befinden. Dies ist die einfachste Möglichkeit für Dialogflow, Sicheren Zugriff auf Ihre Funktion Bevor Sie die Funktion erstellen, wählen Sie Ihr Projekt in der Google Cloud Console aus.

    Zur Projektauswahl

  2. Öffnen Sie die Übersichtsseite für Cloud Run-Funktionen.

    Cloud Run-Funktionen – Übersicht

  3. Klicken Sie auf Funktion erstellen und legen Sie Werte für die folgenden Felder fest:

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

  4. Klicken Sie auf Speichern.

  5. Klicken Sie auf Weiter. Sie benötigen keine speziellen Laufzeit-, Build-, Verbindungs- 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 wurde bereitgestellt. Sehen Sie sich in der Zwischenzeit den Code an, den Sie gerade bereitgestellt haben.

Webhook für Ihren Agenten konfigurieren

Nachdem der Webhook als Dienst vorhanden ist, verknüpfen Sie ihn mit Ihrem Kundenservicemitarbeiter. 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 mit der Webhook-URL, die Sie beim Erstellen der Funktion gespeichert haben.
  8. Legen Sie Subtyp auf „Standard“ fest.
  9. Klicken Sie auf Speichern.

Agent testen

Ihr Agent kann jetzt getestet 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:

Konversationsrunde Ich Agent
1 Hallo! Hallo! Ich bin der virtuelle Kundenservicemitarbeiter für Telekommunikation. Ich kann Ihnen bei Fragen zur Abrechnung und Planung helfen, Fehler beheben und Reise- und Kreuzfahrtpläne hinzufügen. Wie kann ich Ihnen helfen?
2 Ich möchte einen Kreuzfahrtplan hinzufügen Ich sehe mir das genauer an. Wie lautet Ihre Telefonnummer bei uns?
3 123-123-1234 Wie viele Tage dauert die Kreuzfahrt?
4 7 Option 1 umfasst „Sprechen“ und „Text“. Die Kosten betragen [XX] $ pro Tag. Weitere Informationen findest du hier: [URL]. Option 2 umfasst Anrufe, SMS und Daten. Sie kostet [XX] $ pro Tag. Weitere Informationen findest du hier: [URL]. Welchen Kreuzfahrtplan möchten Sie hinzufügen?
5 Option 1 Alles klar. Ich habe diesen Tarif deinem Konto hinzugefügt. Während Ihrer Kreuzfahrt benötigen Sie unter Umständen auch an Land Abdeckung. An welchem Anschluss wirst du halten?
6 Mexiko Und wie viele Tage verbringen Sie dort?
7 3 Außerdem haben wir gute Nachrichten: In Mexiko ist der Netz an Land kostenlos. Das war's! Kann ich sonst noch etwas für Sie tun?

Diese Unterhaltung wurde über den Cruise Plan-Flow verwaltet.

In der Gesprächsrunde Nr. 6 Sie haben „Mexiko“ angegeben als Zielport verwenden. Zielport und Anzahl der Tage dort werden als die Formularparameter destination und trip_duration erfasst. der Collect Port Seite. Suchen Sie in Ihrem Agent nach diesen Parameterdefinitionen.

Screenshot der Seite „Port erfassen“ in der Dialogflow-Konsole

Auf der Seite Collect Port gibt es eine Bedingungsroute für die Formularausführung: $page.params.status = "FINAL". Sobald die beiden Formularparameter angegeben wurden, wird diese Route aufgerufen. Über diese Route wird Ihr Webhook aufgerufen und das cruisePlanCoverage-Tag wird an ihn gesendet. Wenn Sie sich den obigen Webhook-Code ansehen, sehen Sie, dass dieses Tag dieselbe benannte Funktion auslöst, die aufgerufen wird.

Diese Funktion bestimmt, ob das angegebene Ziel durch den Plan abgedeckt ist. Die Funktion prüft, ob bestimmte Umgebungsvariablen festgelegt sind mit Informationen zum Herstellen einer Verbindung zur Datenbank. 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, damit Daten aus einer Datenbank abgerufen werden, um die Planabdeckung für Ziele zu validieren.

Fehlerbehebung

Der Webhook-Code enthält Logging-Anweisungen. Wenn Probleme auftreten, versuchen Sie, Logs ansehen für Ihre Funktion.

Weitere Informationen

Weitere Informationen zu den oben genannten Schritten finden Sie hier:

Zurück
Vordefinierten Agent erstellen
Weiter
Datenbank abfragen