Crie um serviço de webhook

O agente pré-criado que criou no último passo não pode fornecer dados dinâmicos, como saldos da conta, porque tudo está codificado no agente. Neste passo do tutorial, vai criar um webhook que pode fornecer dados dinâmicos ao agente. As funções do Cloud Run são usadas para alojar o webhook neste tutorial devido à sua simplicidade, mas existem muitas outras formas de alojar um serviço de webhook. O exemplo também usa a linguagem de programação Go, mas pode usar qualquer linguagem suportada pelas funções do Cloud Run.

Crie a função

As funções do Cloud Run podem ser criadas com a Google Cloud Console (visite a documentação, abra a consola). Para criar uma função para este tutorial:

  1. É importante que o agente do Dialogflow e a função estejam no mesmo projeto. Esta é a forma mais fácil de o Dialogflow ter acesso seguro à sua função. Antes de criar a função, selecione o seu projeto na Google Cloud consola.

    Aceder ao seletor de projetos

  2. Abra a página de vista geral das funções do Cloud Run.

    Aceda à vista geral das funções do Cloud Run

  3. Clique em Criar função e defina os seguintes campos:

    • Ambiente: 1.ª geração
    • Nome da função: tutorial-banking-webhook
    • Região: se especificou uma região para o seu agente, use a mesma região.
    • Tipo de acionador HTTP: HTTP
    • URL: clique no botão de cópia aqui e guarde o valor. Precisa deste URL quando configurar o webhook.
    • Autenticação: exigir autenticação
    • Exigir HTTPS: selecionado

  4. Clique em Guardar.

  5. Clique em Seguinte (não precisa de definições especiais de tempo de execução, compilação, ligações nem segurança).

  6. Defina os seguintes campos:

    • Tempo de execução: selecione o tempo de execução do Go mais recente.
    • Código fonte: editor inline
    • Ponto de entrada: HandleWebhookRequest

  7. Substitua o código pelo seguinte: 

    package estwh

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 queryResult struct {
	Action     string                 `json:"action"`
	Parameters map[string]interface{} `json:"parameters"`
}

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

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

// 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://godoc.org/google.golang.org/genproto/googleapis/cloud/dialogflow/v2#WebhookRequest
type webhookRequest struct {
	Session     string      `json:"session"`
	ResponseID  string      `json:"responseId"`
	QueryResult queryResult `json:"queryResult"`
}

// 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://godoc.org/google.golang.org/genproto/googleapis/cloud/dialogflow/v2#WebhookResponse
type webhookResponse struct {
	FulfillmentMessages []message `json:"fulfillmentMessages"`
}

// accountBalanceCheck handles the similar named action
func accountBalanceCheck(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	account := request.QueryResult.Parameters["account"].(string)
	account = strings.ToLower(account)
	var table string
	if account == "savings account" {
		table = "Savings"
	} else {
		table = "Checking"
	}
	s := "Your balance is $0"
	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,
			table,
			spanner.Key{1}, // The account ID
			[]string{"Balance"})
		if err != nil {
			if spanner.ErrCode(err) == codes.NotFound {
				log.Printf("Account %d not found", 1)
			} else {
				return webhookResponse{}, err
			}
		} else {
			// A row was returned, so check the value
			var balance int64
			err := row.Column(0, &balance)
			if err != nil {
				return webhookResponse{}, err
			}
			s = fmt.Sprintf("Your balance is $%.2f", float64(balance)/100.0)
		}
	}
	response := webhookResponse{
		FulfillmentMessages: []message{
			{
				Text: text{
					Text: []string{s},
				},
			},
		},
	}
	return response, nil
}

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

// Create a map from action to handler function.
var handlers map[string]handlerFn = map[string]handlerFn{
	"account.balance.check": accountBalanceCheck,
}

// 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 action from the request, and call the corresponding
	// function that handles that action.
	action := request.QueryResult.Action
	if fn, ok := handlers[action]; ok {
		response, err = fn(r.Context(), request)
	} else {
		err = fmt.Errorf("Unknown action: %s", action)
	}
	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. Clique em Implementar.

  9. Aguarde até que o indicador de estado mostre que a função foi implementada com êxito. Enquanto espera, examine o código que acabou de implementar.

Configure o webhook para o seu agente

Agora que o webhook existe como um serviço, tem de associar este webhook ao seu agente. Isto é feito através do processamento. Para ativar e gerir o processamento de pedidos para o seu agente:

  1. Aceda à consola do Dialogflow ES.
  2. Selecione o agente pré-criado que acabou de criar.
  3. Selecione Preenchimento no menu da barra lateral do lado esquerdo.
  4. Ative o campo Webhook.
  5. Indique o URL que copiou acima. Deixe todos os outros campos em branco.
  6. Clique em Guardar na parte inferior da página.

Captura de ecrã da ativação do processamento.

Agora que o processamento de pedidos está ativado para o agente, tem de ativar o processamento de pedidos para uma intenção:

  1. Selecione Intenções no menu da barra lateral esquerda.
  2. Selecione a intenção account.balance.check.
  3. Desloque a página para baixo até à secção Cumprimento.
  4. Ative a opção Ativar chamada de webhook para este objetivo.
  5. Clique em Guardar.

Experimente o agente

O seu agente já está pronto para ser testado. Clique no botão Agente de teste para abrir o simulador. Tente ter a seguinte conversa com o agente:

Interação conversacional Eu Agente
1 Olá, Olá, obrigado por escolher o ACME Bank.
2 Quero saber o saldo da minha conta Para que conta quer o saldo: poupança ou corrente?
3 Verificação Aqui está o seu saldo mais recente: 0,00 $

No turno conversacional n.º 3, indicou "checking" como o tipo de conta. A intenção account.balance.check tem um parâmetro denominado account. Este parâmetro está definido como "checking" nesta conversa. A intenção também tem um valor de ação de "account.balance.check". O serviço de webhook é chamado, e são transmitidos os valores de parâmetro e ação.

Se examinar o código do webhook acima, vai ver que esta ação aciona uma função com um nome semelhante. A função determina o saldo da conta. A função verifica se existem variáveis de ambiente específicas definidas com informações para estabelecer ligação à base de dados. Se estas variáveis de ambiente não estiverem definidas, a função usa um saldo da conta codificado. Nos passos seguintes, vai alterar o ambiente da função para que obtenha dados de uma base de dados.

Resolução de problemas

O código do webhook inclui declarações de registo. Se estiver a ter problemas, experimente ver os registos da sua função.

Mais informações

Para mais informações sobre os passos acima, consulte:

Anterior
Crie um agente pré-criado
Avançar
Consultar uma base de dados