Bauen Sie mit Go eine Zeitkapsel für Glückwünsche zum Geburtstag

Intro

Durch die Pandemie waren wir zeitweise gezwungen, mit unserer Familie und unseren Freunden virtuell zu interagieren. Aber auch mit einer Pandemie geht unser Leben weiter. Es wird immer noch geheiratet, jeder hat einmal im Jahr Geburtstag.

Als mein Geburtstag anstand, erinnerte mich das auch an etwas, was meine Großmutter jedes Jahr tat. Sie rief mich gleich morgens an und sang mir am Telefon "Happy Birthday" vor.

Diese Erinnerung brachte mich auf die Idee, eine Geburtstagszeitkapsel zu erstellen, bei der alle Freunde und Familienmitglieder eine Nummer anrufen. Wenn sie anrufen, können sie ihre Glückwünsche als Sprachaufnahme hinterlassen. Dann erhält man einen Anruf und hört alle Glückwünsche zu einem vorher festgelegten Datum und Zeitpunkt.

Voraussetzungen

Für die Durchführung dieses Tutorials benötigen Sie

• Weiter

• Ngrok

• Eine aktive Rufnummer

Vonage API-Konto

Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.

In diesem Lernprogramm wird auch eine virtuelle Telefonnummer verwendet. Um eine zu erwerben, gehen Sie zu Rufnummern > Rufnummern kaufen und suchen Sie nach einer Nummer, die Ihren Anforderungen entspricht.

Sind Sie bereit, mit dem Bau zu beginnen?

Erleben Sie nahtlose Konnektivität, Echtzeit-Messaging und kristallklare Sprach- und Videoanrufe - alles auf Knopfdruck.

Ngrok-Tunnel erstellen

Wenn Sie Sprachanrufe tätigen oder empfangen, sendet Vonage eine HTTP-Anfrage an Ihre vorkonfigurierten Webhook-URLs. Ihre Anwendung sollte für den Empfang über das Internet erreichbar sein, daher empfehlen wir Ngrok zu verwenden.

Starten Sie ngrok mit dem folgenden Befehl:

Stellen Sie sicher, dass Sie Ihre ngrok-HTTPS-URL kopieren, da Sie diese später für die Konfiguration des Projekts benötigen.

Vonage-Anwendung mit Webhooks erstellen

Da dieses Projekt auf die eingehenden Webhook-Anfragen der Vonage-APIs angewiesen ist, müssen wir eine neue Anwendung erstellen. Machen Sie weiter und erstellen Sie eine neue Anwendung mit den folgenden Eingaben:

• Name - Sie können jeden beliebigen Namen eingeben, den nur Sie sehen werden.

• Fähigkeiten

  • Voice

    • Unter Answer URL hinzufügen: <your ngrok url>/webhooks/answer

    • Unter Event URL hinzufügen: <your ngrok url>/webhooks/event

  • RTC (In-App Voice & Messaging)

    • Unter Event URL hinzufügen: <your ngrok url>/webhooks/event

• Klicken Sie auf "Generate public & private key" und verschieben Sie die private.key Datei in Ihr Projektverzeichnis.

• Klicken Sie auf "Änderungen speichern".

Ihre Anwendung ist nun bereit, Ihnen beliebige vordefinierte Webhooks zu senden!

Hinweis Wenn Sie ngrok ohne Account benutzen, <your ngrok url> jedes Mal anders sein, wenn Sie ngrok ausführen. Denken Sie daran, Ihre Webhook-URLs jedes Mal zu aktualisieren, wenn Sie den Befehl ausführen. Oder melden Sie sich für einen kostenlosen Account an, damit die URL bestehen bleibt.

Voice-Aufnahmen sammeln

Die erste Hälfte dieses Projekts besteht darin, die Voice-Aufnahmen von den Gratulanten zu erhalten.

Erforderliche Pakete installieren

Wir benötigen mehrere Go-Bibliotheken von Drittanbietern, um dieses Projekt erfolgreich durchzuführen. Dazu gehören die folgenden:

• joho/godotenv - zur sicheren Speicherung unserer Vonage-Anmeldedaten

• vonage/vonage-go-sdk - um unsere API-Anfragen bei Vonage zu stellen

• gorm und sqlite um die Dateinamen der Sprachnachrichten und ob sie abgespielt wurden in einer SQLite-Datenbank zu speichern

Um diese Bibliotheken von Drittanbietern zu installieren, führen Sie die folgenden vier Befehle aus:

go get github.com/joho/godotenv
go get github.com/vonage/vonage-go-sdk
go get gorm.io/gorm
go get gorm.io/driver/sqlite

Um das joho/gotdotenv Paket zu nutzen und Ihre Anmeldeinformationen in einer Datei zu speichern, erstellen Sie Ihre .env Datei in Ihrem Projektverzeichnis und fügen Sie die folgenden Variablen hinzu:

Achten Sie darauf, diese Variablen mit den richtigen Werten zu füllen, die Sie in den vorherigen Schritten ermittelt haben. Nachstehend finden Sie eine Liste, wie Sie alle erforderlichen Werte erhalten:

• VONAGE_APPLICATION_ID - Ihre Anwendungs-ID ist die ID, die Sie bei der Erstellung einer Anwendung in Vonage's Dashboard

• VONAGE_PRIVATE_KEY - Der Speicherort der private.key Datei, die sich auf das Projektverzeichnis bezieht

• VONAGE_NUMBER - Ihre Vonage-Nummer ist die virtuelle Telefonnummer, die Sie über das Vonage-Dashboard

• TO_NUMBER - Die Nummer, die den Anruf mit allen Sprachaufzeichnungen zu dem von Ihnen festgelegten Datum und der Uhrzeit erhalten wird

• PERSON_NAME - Name der Person, die diese Glückwünsche erhalten soll

• NGROK_URL - Die ngrok-URL, die Sie in einem früheren Schritt erhalten und gespeichert haben

Strukturen sind typisierte Sammlungen von Feldern, die wir in diesem Tutorial verwenden werden, um Daten aus Webhook-Anfragen zu gruppieren. Erstellen Sie eine neue Datei namens structs.go und fügen Sie das Folgende hinzu:

package main

type Dtmf struct {
	Digits    string
	Timed_out bool
}

type EventResponse struct {
	Conversation_id string
	Type            string
	Body            EventBodyResponse
}

type EventBodyResponse struct {
	Channel EventBodyChannelResponse
}

type EventBodyChannelResponse struct {
	Id   string
	Type string
}

type Recording struct {
	Start_time        string
	Recording_url     string
	Size              int
	Recording_uuid    string
	End_time          string
	Conversation_uuid string
	Timestamp         string
}

type Response struct {
	Speech            []string
	Dtmf              Dtmf
	From              string
	To                string
	Uuid              string
	Conversation_uuid string
	Timestamp         string
}

Nachdem wir nun einige der langweiligen Teile erstellt haben, um loszulegen, erstellen wir die Hauptdatei des Projekts, main.goin Ihrem Projektverzeichnis und fügen Sie den folgenden Code hinzu:

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"

	"github.com/joho/godotenv"
	"github.com/vonage/vonage-go-sdk/jwt"
)

func main() {
	err := godotenv.Load()

	if err != nil {
		log.Fatal("Error loading .env file")
	}

  connectDb()

	http.ListenAndServe(":8080", nil)
}

Der Code im obigen Beispiel ist die Ausgangsstruktur für das Projekt. Er lädt derzeit die Datei .env Datei in das Projekt und erstellt einen Webserver, der auf Port 8080.

Erstellen des Datenbankmodells

Um den Dateinamen der Audiodateien zu speichern und ob sie abgespielt wurden oder nicht, müssen wir eine Datenbank erstellen. Erstellen wir das Modell BirthdayEntry und eine Funktion connectDb() um die Verbindung zu unserer Datenbank herzustellen. Erstellen Sie eine neue Datei namens models.go und fügen Sie den folgenden Code ein:

package main

import (
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

var db *gorm.DB
var err error

type BirthdayEntry struct {
	gorm.Model
	FileName string
	Played   bool
}

func connectDb() {
	db, err = gorm.Open(sqlite.Open("voiceRecordings.db"), &gorm.Config{})

	if err != nil {
		panic("failed to connect database")
	}

	db.AutoMigrate(&BirthdayEntry{})
}

Beantwortung eines Anrufs

Der Aufnahmeprozess einer Sprachnachricht umfasst mehrere Schritte. Der erste Schritt ist die Beantwortung des ersten Anrufs und die Anweisung an die Vonage-APIs, was als nächstes zu tun ist. Erstellen Sie also eine neue Datei in Ihrem Projektverzeichnis mit dem Namen recording.go und fügen Sie das Folgende hinzu:

package main

import (
	"encoding/json"
	"errors"
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"time"

  "github.com/vonage/vonage-go-sdk"
	"github.com/vonage/vonage-go-sdk/ncco"
	"github.com/vonage/vonage-go-sdk/jwt"
)

func answer(w http.ResponseWriter, req *http.Request) {
	MyNcco := ncco.Ncco{}
	talk := ncco.TalkAction{Text: "Thank you for calling the birthday congratulations hotline for " + os.Getenv("PERSON_NAME") + ".. If you would like to leave a message, please press 1. Otherwise end the call. Thank you"}
	MyNcco.AddAction(talk)

	inputAction := ncco.InputAction{EventUrl: []string{"https://" + req.Host + "/webhooks/record"}, Dtmf: &ncco.DtmfInput{MaxDigits: 1}}
	MyNcco.AddAction(inputAction)

	data, _ := json.Marshal(MyNcco)

	w.Header().Set("Content-Type", "application/json")
	w.Write(data)
}

Die obige Funktion erstellt ein neues Call Control Object (NCCO) mit zwei auszuführenden Aktionen. Die erste Aktion ist "Sprechen", wobei vordefinierter Text in Sprache umgewandelt wird, und die zweite Aktion ist die Verarbeitung von Benutzereingaben über Dual Tone Multi-Frequency (DTMF) mit einer anderen vordefinierten Webhook-URL.

Diese Aktionen werden dann in ein JSON-Objekt umgewandelt und in der Anfrage zurückgegeben.

Diese Funktion ist derzeit ungenutzt, das sollten wir ändern! Zurück in main.go innerhalb der main() Funktion fügen Sie die folgende Codezeile ein, die den Webserver anweist, auf die URL zu warten webhooks/answerlauschen soll, und bei Auslösung die answer() Funktion aufruft:

// First Step - Answer phone call
http.HandleFunc("/webhooks/answer", answer)

Aufzeichnung des Gesprächs

Während eines Sprachanrufs wird die Funktion RecordAction im NCCO ausgelöst und beginnt mit der Aufnahme von allem, was Ihr Mikrofon aufnimmt. Wenn Sie die RecordActionauslösen, müssen Sie die Webhook-URL definieren, damit Sie die Details der aufgezeichneten Datei nach Beendigung des Anrufs erhalten.

Um eine Aufzeichnung auszulösen, müssen Sie zunächst zwei neue Routen in Ihrem Webserver registrieren. In Ihrer main.go Datei unterhalb Ihres Aufrufs der answer Funktion fügen Sie die folgenden zwei Zeilen ein:

// Second Step - Take Voice Recording
http.HandleFunc("/webhooks/record", recordUsersMessage)
// Third Step - Receive Voice Recording confirmation + Download the file
http.HandleFunc("/webhooks/recording-file", getFileRecording)

In Ihrer recording.go Datei ist eine der Funktionen, die Sie im obigen Schritt definiert haben, die recordUsersMessage() die ausgelöst wird, wenn der Benutzer seine DTMF-Antwort in den Anruf eingibt (z. B. Drücken der Taste 1). Diese Funktion erstellt einen neuen NCCO, der zunächst einen Text in Sprache umwandelt, sich bedankt und dann auffordert, nach dem Ton eine Nachricht zu hinterlassen.

Die zweite Aktion ist ein RecordActiondie die API anweist, alles aufzuzeichnen, was nach dem Ton gesagt wird. Fügen Sie diese neue Funktion zu Ihrer Datei hinzu:

func recordUsersMessage(w http.ResponseWriter, req *http.Request) {
	data, _ := ioutil.ReadAll(req.Body)
	var response Response
	json.Unmarshal(data, &response)

	MyNcco := ncco.Ncco{}
	talk := ncco.TalkAction{Text: "Thank you. Please leave a message after the tone."}
	MyNcco.AddAction(talk)

	recordAction := ncco.RecordAction{EventUrl: []string{"https://" + req.Host + "/webhooks/recording-file"}, Format: "mp3", BeepStart: true, EndOnSilence: 10}
	MyNcco.AddAction(recordAction)

	responseData, _ := json.Marshal(MyNcco)

	w.Header().Set("Content-Type", "application/json")
	w.Write(responseData)
}

Speichern der Audiodatei

Sobald eine Voice-Aufnahme abgeschlossen ist, wird ein Aufruf an den /webhooks/recording-file Pfad mit JSON ausgelöst, ähnlich wie im folgenden Beispiel:

{
  "start_time": "2020-01-01T12:00:00Z",
  "recording_url": "https://api.nexmo.com/v1/files/aaaaaaaa-bbbb-cccc-dddd-0123456789ab",
  "size": 12345,
  "recording_uuid": "aaaaaaaa-bbbb-cccc-dddd-0123456789ab",
  "end_time": "2020-01-01T12:01:00Z",
  "conversation_uuid": "bbbbbbbb-cccc-dddd-eeee-0123456789ab",
  "timestamp": "2020-01-01T14:00:00.000Z"
}

In diesem JSON-Beispiel können wir die recording_urldie für das Funktionieren unseres Tutorials unerlässlich ist. Diese Aufzeichnungs-URL ist geschützt; Sie müssen ein JSON-Web-Token (JWT) generieren und es mit der GET Anfrage angeben, wenn Sie die Aufzeichnungsdatei abrufen.

Der erste Schritt besteht darin, in der Datenbank eine neue Zeile für diese Datei anzulegen, den Dateinamen zu erstellen (Unix-Zeitstempel) und die downloadFile() Funktion auf. Dann fügen Sie in Ihrer recordings.go Datei die folgende Funktion ein:

func getFileRecording(w http.ResponseWriter, req *http.Request) {
	data, _ := ioutil.ReadAll(req.Body)
	var recording Recording
	json.Unmarshal(data, &recording)

	responseData, _ := json.Marshal(data)

	fileName := strconv.FormatInt(time.Now().UTC().UnixNano(), 10) + ".mp3"
	err := downloadFile(recording.Recording_url, fileName)

	if err != nil {
		log.Fatal(err)
	}

	birthdayEntry := BirthdayEntry{FileName: fileName, Played: false}

	_ = db.Create(&birthdayEntry)

	w.Header().Set("Content-Type", "application/json")
	w.Write(responseData)
}

Herunterladen der Datei

Sie haben vielleicht bemerkt, dass wir die Funktion downloadFile() Funktion im obigen Beispiel noch nicht aufgerufen wurde. Unser nächster Schritt besteht darin, diese Funktion sowie eine weitere Funktion zur Erzeugung unseres JWT hinzuzufügen. Das JWT muss als Header in der Anfrage übergeben werden.
Fügen Sie das Folgende in Ihre recordings.go Datei hinzu. Diese Aktion lädt die Audiodatei von den Vonage-Servern herunter und speichert sie als Datei in dem Verzeichnis recordings Verzeichnis mit dem vorgegebenen Dateinamen.

func downloadFile(audioUrl string, fileName string) error {
	//Get the response bytes from the url
	reqUrl, _ := url.Parse(audioUrl)
	token := generateJWT()
	request := &http.Request{
		Method: "GET",
		URL:    reqUrl,
		Header: map[string][]string{
			"Authorization": {"Bearer " + token},
		},
	}

	response, err := http.DefaultClient.Do(request)

	if err != nil {
		log.Fatal("Error:", err)
	}

	defer response.Body.Close()

	if response.StatusCode != 200 {
		return errors.New("received non 200 response code")
	}

	file, err := os.Create("./recordings/" + fileName)

	if err != nil {
		return err
	}

	defer file.Close()

	_, err = io.Copy(file, response.Body)

	if err != nil {
		return err
	}

	return nil
}

Wir haben immer noch nicht unser JWT-Token generiert! Fügen Sie also mit dem Go SDK von Vonage die folgende Funktion zu recordings.go. Diese Funktion verwendet Ihre VONAGE_APPLICATION_ID und Ihre VONAGE_PRIVATE_KEY_PATH Umgebungsvariablen, um ein neues JWT zu erzeugen.

func generateJWT() string {
	applicationId := os.Getenv("VONAGE_APPLICATION_ID")
	privateKey, _ := ioutil.ReadFile(os.Getenv("VONAGE_PRIVATE_KEY_PATH"))
	g := jwt.NewGenerator(applicationId, privateKey)

	token, _ := g.GenerateToken()

	return token
}

Das war's für den Teil des Systems, der die Sprachanrufe sammelt; bevor wir zur zweiten Hälfte des Tutorials übergehen, wollen wir diese Hälfte von Anfang bis Ende testen.

Stellen Sie zunächst sicher, dass Ihr Projekt ausgeführt wird. Führen Sie in Ihrem Terminal in Ihrem Projektverzeichnis den Befehl aus:

Sie sollten ngrok immer noch laufen haben, also können Sie Ihre virtuelle Vonage-Nummer mit Ihrem Telefon anrufen.

Die erste Antwort ist die folgende Voice-Nachricht: "Vielen Dank für Ihren Anruf bei der Glückwunsch-Hotline zum Geburtstag für <insert name here>.. Wenn Sie eine Nachricht hinterlassen möchten, drücken Sie bitte die 1. Ansonsten beenden Sie den Anruf. Vielen Dank".

Wenn Sie auf Ihrer Tastatur die Eins drücken, hören Sie dann: "Danke. Bitte hinterlassen Sie eine Nachricht nach dem Ton.". Nehmen Sie nun auf, wie Sie ein paar Worte sagen, und legen Sie auf.

Überprüfen Sie einige Sekunden nach Beendigung des Anrufs Ihr recordings Verzeichnis. Sie werden sehen, dass eine neue Datei erstellt wurde.

Es ist an der Zeit, den Teil des Systems für das Geburtstagskind zu bauen!

Anrufen des Geburtstagskindes

Einen Cronjob erstellen und gratulieren

Dieses Projekt benötigt eine Methode, um eine der Funktionen zu einem bestimmten Datum und einer bestimmten Uhrzeit auszuführen.
Der Cron-Job ist ein Zeitplanungsprogramm in Unix-Betriebssystemen. Dieses Projekt wird eine Cron-Bibliothek für Go verwenden, um ein bestimmtes Datum und eine bestimmte Uhrzeit für die Ausführung einer bestimmten Funktion festzulegen.

Führen Sie in Ihrem Terminal den folgenden Befehl aus, um diese Cron-Bibliothek zu installieren:

Innerhalb Ihrer main() Funktion innerhalb Ihrer main.go werden wir eine Funktion aufrufen, die noch erstellt werden muss, runCongratulateCron()also fügen Sie dies unter dem Teil ein, in dem Sie aufrufen connectDb():

runCongratulateCron()

Um die Funktionalität vom ersten Teil des Tutorials zu trennen, fügen wir die notwendige Funktionalität für diesen Teil in einer separaten Datei hinzu. Erstellen Sie eine neue Datei namens congratulate.go und fügen Sie den folgenden Code ein:

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"

  "github.com/robfig/cron"
	"github.com/vonage/vonage-go-sdk"
	"github.com/vonage/vonage-go-sdk/ncco"
)

func runCongratulateCron() {
	c := cron.New()
	// This would be triggered at midnight on 1st Jan
	c.AddFunc("0 0 0 1 1 *", func() {
		congratulate()
	})
	c.Start()
}

func congratulate(w http.ResponseWriter, req *http.Request) {
	privateKey, _ := ioutil.ReadFile(os.Getenv("VONAGE_PRIVATE_KEY_PATH"))
	auth, _ := vonage.CreateAuthFromAppPrivateKey(os.Getenv("VONAGE_APPLICATION_ID"), privateKey)
	client := vonage.NewVoiceClient(auth)

	from := vonage.CallFrom{Type: "phone", Number: os.Getenv("VONAGE_NUMBER")}
	to := vonage.CallTo{Type: "phone", Number: os.Getenv("TO_NUMBER")}

	MyNcco := ncco.Ncco{}

	talkAction := ncco.TalkAction{Text: "Happy Birthday! I have collected a number of recordings from your friends and family wishing you a happy birthday. If you would like to listen to this, please press 1."}
	MyNcco.AddAction(talkAction)

	inputAction := ncco.InputAction{EventUrl: []string{"https://" + os.Getenv("NGROK_URL") + "/webhooks/play-audio"}, Dtmf: &ncco.DtmfInput{MaxDigits: 1}}
	MyNcco.AddAction(inputAction)

	conversationAction := ncco.ConversationAction{Name: os.Getenv("TO_NUMBER"), StartOnEnter: "false"}
	MyNcco.AddAction(conversationAction)

	client.CreateCall(vonage.CreateCallOpts{From: from, To: to, Ncco: MyNcco})
}

Der obige Code hat zwei Funktionen.
Zunächst definiert die runCongratulateCron() Funktion einen neuen Cronjob und fügt die angegebene Zeit hinzu, zu der das Geburtstagskind seinen Anruf erhalten soll. Wenn Sie unsicher sind, wie Sie die Zeiten mit einem Cronjob einrichten, lesen Sie bitte den Crontab-Guru um Ihr eigenes Zeitset zu erstellen.

Die zweite Funktion wird von der ersten aufgerufen, und diese führt den ausgehenden Text-To-Speech-Sprachanruf an das Geburtstagskind durch und fragt es dann nach einer InputAction ("Press 1 to continue"). Um den Anruf für den Empfänger aktiv zu halten, wird ein ConversationAction benötigt. Wir werden im nächsten Schritt lernen, wie man den Ton in den Anruf einspielt, aber dies muss in einem aktiven Gespräch geschehen.

Audio in einen Anruf einspielen

Nun, da wir einen Anruf haben, müssen wir den Code zum Abspielen der Audiodateien in den Voice-Anruf einfügen. Dazu müssen Sie die UUID erfassen und sie in eine Anfrage einfügen, die die PlayAudioStream Funktion aufruft, zusammen mit der URL der Datei, die Sie zuerst abspielen möchten.

Hinweis Sie können die Audiodateien nicht in eine Warteschlange stellen. Wenn Sie jede Audiodatei in einer Schleife abspielen, wird jede Audiodatei mit der neuesten unterbrochen. Um dies zu vermeiden, müssen wir die Datei abspielen und dann auf ein Ereignis warten, das nach Abschluss der Wiedergabe eintrifft. Wir suchen dann die nächste noch nicht abgespielte Datei in der Datenbank und spielen diese nach Abschluss der vorherigen Audiodatei ab.

Also, in congratulate.go den folgenden Code ein:

func congratulatePlayAudio(w http.ResponseWriter, req *http.Request) {
	data, _ := ioutil.ReadAll(req.Body)
	var response Response
	json.Unmarshal(data, &response)

	playAudio(response.Uuid, req.Host)
}

func playAudio(uuid string, host string) {
	var birthdayEntry BirthdayEntry

	privateKey, _ := ioutil.ReadFile(os.Getenv("VONAGE_PRIVATE_KEY_PATH"))
	auth, _ := vonage.CreateAuthFromAppPrivateKey(os.Getenv("VONAGE_APPLICATION_ID"), privateKey)
	client := vonage.NewVoiceClient(auth)

	if err := db.First(&birthdayEntry, "played = ?", false).Error; err != nil {
		client.PlayTts(uuid, "This is the end of your birthday wishes, you may now hang up.", vonage.PlayTtsOpts{})

		return
	}

	fmt.Println("https://" + host + "/" + birthdayEntry.FileName)

	result, _, _ := client.PlayAudioStream(uuid,
		"https://"+host+"/"+birthdayEntry.FileName,
		vonage.PlayAudioOpts{},
	)

	birthdayEntry.Played = true
	db.Save(&birthdayEntry)

	fmt.Println("Update message: " + result.Message)
}

In main.go finden Sie die Zeile http.HandleFunc("/webhooks/recording-file", getFileRecording) und fügen Sie das Folgende hinzu:

http.HandleFunc("/congratulate", congratulate)
http.HandleFunc("/webhooks/play-audio", congratulatePlayAudio)

Anforderung zum Abspielen der nächsten Audiodatei auslösen

Wie bereits besprochen, müssen wir die nächste Audiodatei in den Anruf einspielen, sobald die vorherige beendet ist. Mit der zuvor definierten Webhook-URL unter: RTC (In-app voice & messaging) im Dashboard werden wir auf ein bestimmtes Ereignis warten, das einen bestimmten Schlüssel in der Anfrage enthält. Durch das Abhören des event.type Teil der Anfrage abhören, können wir prüfen, ob der Wert lautet: audio:play:doneist, und rufen dann die Funktion playAudio auf, um die folgende nicht abgespielte Audiodatei zu finden.

Innerhalb congratulate.go fügen Sie diese neue event Funktion ein:

func event(w http.ResponseWriter, req *http.Request) {
	var event EventResponse

	err := json.NewDecoder(req.Body).Decode(&event)

	if err != nil {
		return
	}

	if event.Type == "audio:play:done" {
		playAudio(event.Body.Channel.Id, req.Host)
	}
}

Dann, in main.gounter der Zeile http.HandleFunc("/webhooks/play-audio", congratulatePlayAudio) hinzufügen:

http.HandleFunc("/webhooks/event", event)

Das war's! Wir haben jetzt unsere Zeitkapsel für Geburtstagsfeiern mit Go erstellt! Im Folgenden gehen wir Schritt für Schritt vor, um die Funktionalität zu testen.

Testen Sie es!

Nachdem wir nun dieses Projekt erstellt haben, wollen wir den Prozess von Anfang bis Ende skizzieren:

1. Gratulanten rufen Ihre virtuelle Vonage-Nummer an

2. Ihre App beantwortet den Anruf mit einer Text-To-Speech-Nachricht: "Vielen Dank für Ihren Anruf bei der Geburtstagsglückwunsch-Hotline für <insert name here>.. Wenn Sie eine Nachricht hinterlassen möchten, drücken Sie bitte die 1. Andernfalls beenden Sie bitte den Anruf. Vielen Dank!"

3. Die App wartet darauf, dass Sie eine Zahl auf Ihrer Tastatur eingeben.

4. Der nächste Webhook empfängt eine Anfrage und sendet eine Text-To-Speech-Nachricht: "Danke. Bitte hinterlassen Sie eine Nachricht nach dem Ton."

5. Es ertönt ein Signalton, und der Anruf zeichnet nun alles auf, was von Ihrem Mikrofon aufgenommen wird.

6. Sie beenden das Gespräch, wenn Sie fertig sind.

Allerdings können viele Gratulanten die Schritte 1-6 dort wiederholen.

1. Zum angegebenen Zeitpunkt (definiert in der runCongratulateCron() Funktion definiert), wird die Funktion congratulate() aufgerufen.

2. Die Bewerbung an das Geburtstagskind führt einen ausgehenden Anruf durch.

3. Wenn Sie den Anruf entgegennehmen, wird der Empfänger mit "Happy Birthday! Ich habe mehrere Aufnahmen von Ihren Freunden und Ihrer Familie gesammelt, die Ihnen zum Geburtstag gratulieren. Wenn Sie diese anhören möchten, drücken Sie bitte die 1.

4. Der Anruf wartet nun darauf, dass der Empfänger eine Nummer auf seinem Tastenfeld drückt.

5. Die Anwendung ruft dann die erste nicht abgespielte Audiodatei aus der Datenbank ab und streamt sie in den Sprachanruf.

6. Nach Abschluss des Audiodateistreams wird ein Ereignis an die Anwendung zurückgesendet. Wenn dieses Ereignis empfangen wird, sucht die Anwendung die nächste noch nicht abgespielte Audiodatei und streamt sie durch den Aufruf.

7. Wenn es keine nicht abgespielten Audiodateien mehr gibt, wird der Anruf beendet.

Sie haben jetzt eine Zeitkapsel für Geburtstagsfeiern mit Go integriert, indem Sie die Voice API von Vonage verwenden. Das angegebene Beispiel ist nur eine von vielen Möglichkeiten, die Voice API zu nutzen.

Wenn dieses Tutorial Ihr Interesse an unserer Voice API geweckt hat, Go aber nicht die Sprache Ihrer Wahl ist, finden Sie weitere Tutorials in verschiedenen Sprachen oder Diensten hier auf dem Vonage-Blogwie zum Beispiel:

• Zufällige Fakten Voice-Anruf mit PHP, Uselessfacts und AWS Lambda

• Verbinden von Voice-Anrufen mit einem Amazon Lex Bot

• Einführung der Vonage Voice API auf Zapier

• Erstellen einer interaktiven Voice-Antwort mit Go

Wenn Sie Fragen, Ratschläge oder Ideen haben, die Sie mit der Community teilen möchten, können Sie sich gerne in unserem Slack-Arbeitsbereich der Gemeinschaftoder kontaktieren Sie mich auf Twitter. Ich würde mich freuen, von allen zu hören, die dieses Tutorial implementiert haben und wie Ihr Projekt funktioniert.