创建网络钩子服务

您在上一步中创建的预构建代理需要 webhook。 本教程中，我们使用 Cloud Run 函数托管网络钩子，因为它们简单易用，但您还可以通过许多其他方式托管网络钩子服务。该示例还使用了 Go 编程语言，但您可以使用 Cloud Run 函数支持的任何语言。

创建函数

您可以使用 Google Cloud 控制台（访问文档，打开控制台）创建 Cloud Run 函数。如需为本教程创建函数，请执行以下操作：

1. 请务必确保您的 Dialogflow 代理和 它们属于同一个项目 对于 Dialogflow 来说，这是 安全地访问函数。 在创建函数之前，请从 Google Cloud 控制台中选择您的项目。

   转到“项目选择器”

2. 打开 Cloud Run 函数概览页面。

   前往 Cloud Run 函数概览

3. 点击创建函数，并设置以下字段：

   • 环境：第 1 代
   • 函数名称：tutorials-telecommunications-webhook
   • 区域：如果您为代理指定了区域，请使用相同的区域。
   • HTTP 触发器类型：HTTP
   • 网址：点击此处的复制按钮并保存相应值。 您在配置该网络钩子时需要使用此网址。
   • 身份验证：需要进行身份验证
   • 需要 HTTPS：已选中

4. 点击保存。

5. 点击下一步（您无需特殊的运行时、构建、连接或安全设置）。

6. 设置以下字段：

   • 运行时：选择最新的 Go 运行时。
   • 源代码：内嵌编辑器
   • 入口点：HandleWebhookRequest

7. 将代码替换为以下代码：

   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. 点击部署。

9. 等待状态指示器显示函数 已成功部署 等待期间，检查您刚刚部署的代码。

为代理配置网络钩子

现在，该网络钩子已作为服务存在，您需要将此网络钩子与您的代理相关联。如需为您的代理配置 webhook，请执行以下操作：

1. 打开 Dialogflow CX 控制台。
2. 选择您的 Google Cloud 项目。
3. 选择您的代理。
4. 选择管理标签页。
5. 点击网络钩子。
6. 点击现有 webhook（由预构建的代理创建）。
7. 将 Webhook 网址更新为您在创建函数时保存的 Webhook 网址。
8. 将子类型设置为“标准”。
9. 点击保存。

试用代理

您的代理现在已准备就绪，可以进行试用了。 点击测试代理按钮以打开模拟器。尝试与代理进行以下对话：

对话回合	您	代理
1	您好！	您好！我是虚拟电信客服人员。我可以帮助您解决结算和计划问题、排查问题以及添加旅行和游轮计划。您现在需要什么帮助？
2	我想添加游轮计划	让我为您看看。您向我们提供的手机号码是多少？
3	123-123-1234	您的游轮行程有几天？
4	7	选项 1 包括通话和短信功能。费用为 [XX] 美元/天。如需了解详情，请点击此处 [网址]。选项 2 包括通话、短信和移动流量。每天的费用为 [XX] 美元。有关详情，请点击此处：[网址]。您要添加哪个邮轮计划？
5	选项 1	Got it.我已将该方案添加到您的账号中。在游轮上航行时，您可能还需要陆地覆盖。您要在哪个港口停靠？
6	墨西哥	您要在那里停留几天？
7	3	好消息！墨西哥境内陆地范围内免费。大功告成！您现在还需要其他方面的帮助吗？

这一特定对话由 Cruise Plan 流管理。

在第 6 轮对话中，您提供了“墨西哥”作为目的地港口。目的地端口及其天数 以 destination 和 trip_duration 表单参数的形式捕获 位于 Collect Port 页面上。 浏览您的代理以查找这些参数定义。

在 Collect Port 页面中，有一个表单完成条件路由：$page.params.status = "FINAL"。提供这两个表单参数后 就会被调用 此路由会调用您的网络钩子，并向您的网络钩子提供 cruisePlanCoverage 标记。如果查看上面的网络钩子代码， 您会发现此代码会触发调用同一命名函数。

此函数用于确定所提供的目的地 。 该函数检查是否设置了特定的环境变量 以及用于连接到数据库的信息。 如果未设置这些环境变量，该函数将使用硬编码的目标列表。在后续步骤中 您将更改函数的环境 以便从数据库中检索数据 以验证方案覆盖范围。

问题排查

webhook 代码包含日志记录语句。 如果您遇到问题，请尝试查看函数的日志。

更多信息

如需详细了解上述步骤，请参阅：

• Cloud Run Functions Go 快速入门