Construire une capsule temporelle de félicitations d'anniversaire avec Go

Intro

Avec la pandémie, nous avons parfois été contraints d'avoir des interactions virtuelles avec notre famille et nos amis. Mais même avec une pandémie, nos vies ont continué. Les gens continuent de se marier, les anniversaires reviennent une fois par an pour tout le monde.

Aussi, lorsque mon anniversaire est arrivé, il m'a rappelé une chose que ma grand-mère avait l'habitude de faire chaque année. Elle m'appelait à la première heure du matin et me chantait un joyeux anniversaire au téléphone.

Ce souvenir a fait germer dans ma tête l'idée de créer une capsule temporelle d'anniversaire où tous vos amis et votre famille appelleraient un numéro. Lorsqu'ils appellent, ils peuvent laisser leurs vœux sous la forme d'un enregistrement vocal. Ensuite, vous recevriez un appel et entendriez tous les enregistrements de vœux à une date et une heure prédéterminées.

Conditions préalables

Pour réaliser ce tutoriel, vous aurez besoin de :

• Aller

• Ngrok

• Un numéro de téléphone actif

Vonage API Account

To complete this tutorial, you will need a Vonage API account. If you don’t have one already, you can sign up today and start building with free credit. Once you have an account, you can find your API Key and API Secret at the top of the Vonage API Dashboard.

This tutorial also uses a virtual phone number. To purchase one, go to Numbers > Buy Numbers and search for one that meets your needs.

Ready to start building?

Experience seamless connectivity, real-time messaging, and crystal-clear voice and video calls—all at your fingertips.

Créer le tunnel de Ngrok

Lors de l'émission ou de la réception d'appels vocaux, Voice enverra une requête HTTP à vos URL de webhook préconfigurées. Votre application doit être accessible à l'internet pour la recevoir, c'est pourquoi nous recommandons d'utiliser Ngrok.

Lancez ngrok avec la commande suivante :

Veillez à copier l'URL HTTPS de ngrok, car vous en aurez besoin plus tard lors de la configuration du projet.

Créer une application Vonage avec Webhooks

Ce projet s'appuiera sur l'écoute des requêtes webhook entrantes effectuées par les API de Vonage, nous devrons donc créer une nouvelle application. Allez-y et créez une nouvelle application avec les données d'entrée suivantes :

• Nom - Vous pouvez choisir n'importe quel nom ; c'est un nom que vous serez le seul à voir.

• Capacités

  • Voice

    • Sous Answer URL ajouter : <your ngrok url>/webhooks/answer

    • Sous Event URL ajouter : <your ngrok url>/webhooks/event

  • RTC (In-App Voice & Messaging)

    • Sous Event URL ajouter : <your ngrok url>/webhooks/event

• Cliquez sur "Generate public & private key" et déplacez le fichier private.key dans le répertoire de votre projet.

• Cliquez sur "Enregistrer les modifications"

Votre application est désormais prête à vous envoyer n'importe quel webhook prédéfini !

Remarque Si vous utilisez ngrok sans Account, <your ngrok url> sera différente à chaque fois que vous lancerez ngrok. Pensez à mettre à jour vos URLs de webhooks à chaque fois que vous exécutez la commande. Sinon, créez un compte gratuit pour que l'URL persiste.

Collecter des enregistrements Voice

La première moitié de ce projet consiste à recevoir les enregistrements vocaux des bienfaiteurs.

Installer les paquets requis

Nous aurons besoin de plusieurs bibliothèques Go tierces pour mener à bien ce projet. Il s'agit notamment des bibliothèques suivantes :

• joho/godotenv - pour stocker en toute sécurité nos informations d'identification Vonage

• vonage/vonage-go-sdk - pour faire nos demandes d'API à Vonage

• gorm et sqlite pour stocker les noms des fichiers de messages vocaux et indiquer s'ils ont été lus dans une base de données SQLite

Pour installer ces bibliothèques tierces, exécutez les quatre commandes suivantes :

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

Pour utiliser le paquet joho/gotdotenv et commencer à stocker vos informations d'identification dans un fichier, créez votre fichier .env dans le répertoire de votre projet et ajoutez les variables suivantes :

Veillez à remplir ces variables avec les valeurs correctes que vous avez recueillies au cours des étapes précédentes. Vous trouverez ci-dessous une liste des méthodes permettant d'obtenir toutes les valeurs requises :

• VONAGE_APPLICATION_ID - L'ID de votre application est l'ID donné lorsque vous avez créé une application dans le tableau de bord

• VONAGE_PRIVATE_KEY - L'emplacement du fichier private.key dans le répertoire du projet

• VONAGE_NUMBER - Votre numéro Vonage est le numéro de téléphone virtuel que vous avez acheté dans le tableau de bord Vonage

• TO_NUMBER - Le numéro qui recevra l'appel avec tous les enregistrements vocaux à la date et à l'heure que vous aurez déterminées.

• PERSON_NAME - Le nom de la personne qui recevra ces vœux.

• NGROK_URL - L'URL ngrok que vous avez reçu et stocké lors d'une étape précédente

Les structures sont des collections typées de champs que nous utiliserons pour regrouper les données provenant des requêtes webhook tout au long de ce tutoriel. Créez un nouveau fichier appelé structs.go et ajoutez ce qui suit :

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
}

Maintenant que nous avons créé quelques éléments ennuyeux pour commencer, créons le fichier principal du projet, main.godans le répertoire de votre projet et ajoutons-y le code suivant :

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)
}

Le code de l'exemple ci-dessus est la structure initiale du projet. Il charge actuellement le fichier .env dans le projet et crée un serveur web écoutant sur le port 8080.

Création du modèle de base de données

Pour enregistrer le nom des fichiers audio et savoir s'ils ont été lus ou non, nous devons créer une base de données. Créons le modèle BirthdayEntry et une fonction connectDb() pour gérer la connexion à notre base de données. Créez un nouveau fichier appelé models.go et ajoutez le code suivant :

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{})
}

Gestion de la réponse à un appel

Le processus d'enregistrement d'un message vocal comporte plusieurs étapes. La première répondra à l'appel initial et indiquera aux API de Vonage la marche à suivre. Créez donc un nouveau fichier dans le répertoire de votre projet, appelé recording.go et ajoutez ce qui suit :

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)
}

La fonctionnalité ci-dessus créera un nouvel objet de contrôle d'appel (NCCO) avec deux actions à effectuer. La première action consistera à "parler", en convertissant un texte prédéfini en Voice, et la seconde à gérer l'entrée de l'utilisateur via Dual Tone Multi-Frequency (DTMF), avec une autre URL webhook prédéfinie.

Ces actions sont ensuite converties en un objet JSON et renvoyées dans la demande.

Cette fonction est actuellement inutilisée, alors changeons cela ! Retourner dans main.go dans la fonction main() ajoutez la ligne de code suivante, qui indique au serveur web d'écouter l'URL webhooks/answeret, lorsqu'elle est déclenchée, d'appeler la fonction answer() fonction :

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

Enregistrement de l'appel

Lors d'un appel vocal, la fonction RecordAction du NCCO se déclenche et commence à enregistrer tout ce que votre microphone capte. Lorsque vous déclenchez le RecordActionvous devez définir l'URL du webhook qui vous fournira les détails du fichier enregistré à la fin de l'appel.

Pour déclencher un enregistrement, vous devez d'abord enregistrer deux nouvelles routes dans votre serveur web. Dans votre fichier main.go sous votre appel à la fonction answer ajoutez les deux lignes suivantes :

// 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)

Dans votre fichier recording.go l'une des fonctions que vous avez définies à l'étape précédente est la fonction recordUsersMessage() déclenchée lorsque l'utilisateur introduit sa réponse DTMF dans l'appel (en appuyant sur 1, par exemple). Cette fonction créera un nouveau NCCO, qui convertira d'abord un texte en parole, remerciant l'utilisateur, puis lui demandant de laisser un message après la tonalité.

La deuxième action est un RecordActionqui indique à l'API d'enregistrer ce qui est dit après le signal sonore. Ajoutez cette nouvelle fonction à votre fichier :

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)
}

Enregistrement du fichier audio

Une fois l'enregistrement vocal terminé, un appel au chemin d'accès /webhooks/recording-file est déclenché avec du JSON, comme dans l'exemple ci-dessous :

{
  "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"
}

Dans cet exemple JSON, nous pouvons voir la balise recording_urlqui est essentiel pour que notre tutoriel fonctionne. Cette URL d'enregistrement est protégée ; vous devez générer un jeton Web JSON (JWT) et le fournir avec la requête GET lors de l'extraction du fichier d'enregistrement.

La première étape consiste à créer une nouvelle ligne dans la base de données pour ce fichier, à créer le nom du fichier (horodatage Unix) et à appeler la fonction downloadFile() et d'appeler la fonction Ensuite, dans votre fichier recordings.go ajoutez la fonction suivante :

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)
}

Téléchargement du fichier

Vous avez peut-être remarqué que nous n'avons pas encore appelé la fonction downloadFile() appelée dans l'exemple ci-dessus. Notre prochaine étape est d'ajouter cette fonction ainsi qu'une autre fonction pour générer notre JWT. Le JWT doit être transmis en tant qu'en-tête dans la requête.
Ajoutez ce qui suit à votre fichier recordings.go le texte suivant. Cette action téléchargera le fichier audio depuis les serveurs de Vonage et l'enregistrera en tant que fichier dans le répertoire recordings avec le nom de fichier prédéterminé.

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
}

Nous n'avons toujours pas généré notre jeton JWT ! Donc, en utilisant le SDK Go de Vonage, ajoutez la fonction suivante à recordings.go. Cette fonction utilise vos VONAGE_APPLICATION_ID et votre VONAGE_PRIVATE_KEY_PATH pour générer un nouveau JWT.

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
}

C'est tout pour la partie du système qui collecte les appels vocaux ; avant de passer à la deuxième partie du tutoriel, nous allons vouloir tester cette partie du début à la fin.

Tout d'abord, assurez-vous que votre projet est en cours d'exécution. Dans votre Terminal, dans le répertoire de votre projet, exécutez la commande :

Vous devriez toujours avoir ngrok en marche, alors allez-y et appelez votre numéro virtuel Vonage à l'aide de votre téléphone.

La première réponse est le message vocal suivant : "Merci d'avoir appelé le service d'assistance téléphonique pour les félicitations d'anniversaire. <insert name here>.. Si vous souhaitez laisser un message, appuyez sur 1. Sinon, mettez fin à l'appel. Nous vous remercions".

Si vous appuyez sur la touche 1 de votre clavier, vous entendrez : "Merci. Veuillez laisser un message après la tonalité". Enregistrez-vous en train de dire quelques mots et raccrochez.

Quelques secondes après la fin de l'appel téléphonique, consultez votre recordings répertoire. Vous verrez qu'un nouveau fichier a été créé.

Il est temps de construire la partie du système destinée à la personne dont c'est l'anniversaire !

Appeler la personne qui fête son anniversaire

Créer un Cronjob et féliciter

Ce projet a besoin d'une méthode pour exécuter l'une des fonctions à une date et une heure spécifiques.
Le job cron est un planificateur de temps dans les systèmes d'exploitation Unix. Ce projet utilisera une bibliothèque cron pour Go afin de définir une date et une heure particulières pour l'exécution d'une fonction spécifique.

Dans votre Terminal, exécutez la commande ci-dessous pour installer cette bibliothèque cron :

A l'intérieur de votre fonction main() à l'intérieur de votre main.go nous allons appeler une fonction qui n'a pas encore été créée, runCongratulateCron()ajoutez donc ceci en dessous de la partie où vous appelez connectDb():

runCongratulateCron()

Afin de séparer la fonctionnalité de la première partie du tutoriel, nous ajouterons la fonctionnalité nécessaire à cette partie dans un fichier séparé. Créez un nouveau fichier appelé congratulate.go et ajoutez le code suivant :

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})
}

Le code ci-dessus a deux fonctions.
Tout d'abord, la fonction runCongratulateCron() définit un nouveau cronjob et ajoute l'heure spécifiée pour que la personne dont c'est l'anniversaire reçoive son appel téléphonique. Si vous n'êtes pas sûr de savoir comment configurer les heures avec un cronjob, veuillez consulter la rubrique Guru Crontab pour créer votre jeu d'heures personnalisé.

La deuxième fonction est appelée à partir de la première, et elle effectue l'appel vocal Text-To-Speech sortant à la personne qui fête son anniversaire, puis lui demande une InputAction ("Appuyez sur 1 pour continuer"). Pour que l'appel reste actif pour le destinataire, une fonction ConversationAction est nécessaire. Nous verrons comment diffuser l'audio dans l'appel à l'étape suivante, mais cela doit se faire dans le cadre d'une conversation active.

Lire l'audio dans un appel

Maintenant que nous avons un appel, nous devons ajouter le code pour lire les fichiers audio dans l'appel Voice. Pour ce faire, vous devrez récupérer l'UUID et le passer dans une requête appelant la fonction PlayAudioStream avec l'URL du fichier que vous souhaitez lire en premier.

Remarque vous ne pouvez pas mettre les fichiers audio en file d'attente. Si vous lisez en boucle chaque fichier audio dans l'appel, chaque fichier audio sera interrompu par le plus récent. Pour éviter cela, nous devons lire le fichier et attendre qu'un événement se produise à la fin de la lecture. Nous trouvons alors le prochain fichier non joué dans la base de données et le jouons à la fin de la lecture du fichier audio précédent.

Ainsi, dans congratulate.go ajouter le code suivant :

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)
}

En main.go trouver la ligne http.HandleFunc("/webhooks/recording-file", getFileRecording) et ajoutez ce qui suit :

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

Demande de déclenchement de la lecture du fichier audio suivant

Comme nous l'avons vu précédemment, nous devons lire le fichier audio suivant dans l'appel après avoir terminé le précédent. En utilisant l'URL webhook définie précédemment sous : RTC (In-app voice & messaging) dans le tableau de bord, nous écouterons un événement spécifique qui contient une clé particulière dans la demande. En écoutant la partie event.type de la requête, nous pourrons vérifier si la valeur est : audio:play:doneet appeler la fonction playAudio pour trouver le fichier audio non lu suivant.

A l'intérieur congratulate.go ajoutez cette nouvelle event fonction :

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)
	}
}

Ensuite, dans main.gosous la ligne http.HandleFunc("/webhooks/play-audio", congratulatePlayAudio) ajouter :

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

Voilà, c'est fait ! Nous avons maintenant créé notre capsule temporelle de célébrations d'anniversaires avec Go ! Ci-dessous, nous allons suivre le processus étape par étape pour tester la fonctionnalité.

Testez-le !

Maintenant que nous avons construit ce projet, décrivons le processus du début à la fin :

1. Les sympathisants appellent votre numéro virtuel Vonage

2. Votre appli répond à l'appel par un message en synthèse vocale : " Merci d'avoir appelé le service d'assistance téléphonique pour les félicitations d'anniversaire pour... ". <insert name here>.. Si vous souhaitez laisser un message, appuyez sur 1. Sinon, mettez fin à l'appel. Nous vous remercions"

3. L'appli attend que vous saisissiez un numéro sur votre clavier.

4. Le crochet web suivant reçoit une demande et envoie un message en synthèse vocale : "Merci. Veuillez laisser un message après la tonalité."

5. Un bip se fait entendre et l'appel enregistre maintenant tout ce qui est capté par votre microphone.

6. Vous mettez fin à l'appel lorsque vous avez terminé.

Cependant, de nombreux bienfaiteurs peuvent répéter les étapes 1 à 6.

1. Au moment spécifié (défini dans la runCongratulateCron() ), la fonction congratulate() est appelée.

2. L'application destinée à la personne dont c'est l'anniversaire passe un appel sortant.

3. En répondant à l'appel, le destinataire se voit présenter "Joyeux anniversaire ! J'ai recueilli plusieurs enregistrements de vos amis et de votre famille vous souhaitant un joyeux anniversaire. Si vous souhaitez les écouter, veuillez appuyer sur la touche 1."

4. L'appel attend maintenant que le destinataire appuie sur un numéro de son clavier.

5. L'application récupère alors le premier fichier audio non lu dans la base de données et le diffuse dans l'appel vocal.

6. Lorsque le flux de fichiers audio est terminé, un événement est renvoyé à l'application. Lorsque cet événement est reçu, l'application recherche le prochain fichier audio non lu et le diffuse par l'intermédiaire de l'appel.

7. Lorsqu'il n'y a plus de fichiers audio non lus, l'appel est terminé.

Vous avez maintenant intégré une capsule temporelle de célébration d'anniversaire avec Go, en utilisant l'API Voice de Vonage. L'exemple fourni n'est qu'une des nombreuses façons d'utiliser l'API Voice.

Si ce tutoriel a éveillé votre intérêt pour notre Voice API, mais que Go n'est pas la langue de votre choix, d'autres tutoriels dans différentes langues ou services peuvent être trouvés ici sur le blog de Vonagetels que :

• Appel vocal de faits aléatoires avec PHP, Uselessfacts et AWS Lambda

• Connecter des appels vocaux à un bot Amazon Voice

• Présentation de l'API Voice de Vonage sur Zapier

• Créer une réponse vocale interactive avec Go

Si vous avez des questions, des conseils ou des idées que vous souhaitez partager avec la communauté, n'hésitez pas à vous rendre sur notre espace de travail Slack de la communautéou contactez-moi sur Twitter. J'aimerais avoir le retour de tous ceux qui ont mis en œuvre ce tutoriel et savoir comment leur projet fonctionne.