Bird a récemment lancé les Conversations Programmables. Cela permet aux entreprises d'intégrer des plateformes de communication comme WhatsApp, Messenger et SMS dans leurs systèmes — en utilisant une seule API.

Je voulais essayer, alors j'ai construit un bot WhatsApp pour les listes de tâches, car qui n’a pas besoin d’une liste de tâches automatisée pour organiser sa journée ? Cela peut paraître compliqué, mais c’était en fait facile, et j’aimerais tout vous raconter à ce sujet.

Maintenant, je travaille chez MessageBird, donc je pouvais simplement y plonger et commencer à construire. Si vous essayez cela, vous devrez demander un accès anticipé. Mais une fois que vous êtes configuré avec un canal WhatsApp, vous pouvez vous connecter au Tableau de bord sur le site MessageBird et commencer.

La première chose que j'ai faite a été de lire les docs. J'ai appris que, pour recevoir des messages du bot, je devrais utiliser un webhook. Cela signifiait que mon bot devrait être accessible depuis Internet. Comme je venais juste de commencer à le coder, j'ai décidé d'utiliser ngrok. Il crée un tunnel de l'internet public vers votre cher port localhost 5007. Engage!

ngrok http 5007 -region eu -subdomain todobot

Ensuite, j'avais besoin de faire un appel à l'API des Conversations Programmables pour créer le webhook. C'est un POST vers https://conversations.messagebird.com/v1/webhooks et cela ressemble à ceci :

func main() {// définir le payload json du webhook
       wh := struct {
               Events    []string `json:"events"`
               ChannelID string   `json:"channelId"`
               URL       string   `json:"url"`
       } {// nous aimerions être notifiés sur l'URL
               URL:       "https://todobot.eu.ngrok.io/create-hook",
               // chaque fois qu'un message est créé
               Events:    []string{"message.created"},
               // sur le canal WhatsApp avec ID
               ChannelID: "23a780701b8849f7b974d8620a89a279",
       }// encoder le payload en json
       var b bytes.Buffer
       err := json.NewEncoder(&b).Encode(&wh)
       if err != nil {
               panic(err)
       }// créer la requête http et définir l'en-tête d'autorisation
       req, err := http.NewRequest("POST", "https://conversations.messagebird.com/v1/webhooks", &b)
       req.Header.Set("Authorization", "AccessKey todo-your-access-key")
       req.Header.Set("Content-Type", "application/json")// envoyer la requête http
       client := &http.Client{}
       resp, err := client.Do(req)
       if err != nil {
               panic(err)
       }
       defer resp.Body.Close()// tout est ok?
       body, _ := ioutil.ReadAll(resp.Body)
       if resp.StatusCode >= http.StatusBadRequest {
               panic(fmt.Errorf("Code de réponse incorrect de l'api lors de la tentative de création du webhook : %s. Corps : %s", resp.Status, string(body)))
       } else {
               log.Println("Tout est bon. corps de réponse : ", string(body))
       }
}

Cool. Maintenant, l'API Conversations va faire une requête POST à :

https://todobot.eu.ngrok.io/create-hook chaque fois qu'un nouveau message sera créé sur le canal WhatsApp que vous avez configuré précédemment.

Voici à quoi ressemble une charge utile de webhook :

{
    "conversation":{
       "id":"55c66895c22a40e39a8e6bd321ec192e",
       "contactId":"db4dd5087fb343738e968a323f640576",
       "status":"active",
       "createdDatetime":"2018-08-17T10:14:14Z",
       "updatedDatetime":"2018-08-17T14:30:31.915292912Z",
       "lastReceivedDatetime":"2018-08-17T14:30:31.898389294Z"
    },
    "message":{
       "id":"ddb150149e2c4036a48f581544e22cfe",
       "conversationId":"55c66895c22a40e39a8e6bd321ec192e",
       "channelId":"23a780701b8849f7b974d8620a89a279",
       "status":"received",
       "type":"text",
       "direction":"received",
       "content":{
          "text":"add buy milk"
       },
       "createdDatetime":"2018-08-17T14:30:31.898389294Z",
       "updatedDatetime":"2018-08-17T14:30:31.915292912Z"
    },
    "type":"message.created"
}

Nous voulons répondre à ces messages. Commençons par les faire écho. Qu'en dites-vous ?

// définir les structures où nous analyserons la charge utile du webhook du type whPayload struct {
       Conversation conversation `json:"conversation"`
       Message      message      `json:"message"`
       Type         string       `json:"type"`
}type message struct {
       ID        string  `json:"id"`
       Direction string  `json:"direction"`
       Type      string  `json:"type"`
       Content   content `json:"content"`
}type content struct {
       Text string `json:"text"`
}type conversation struct {
       ID string `json:"id"`
}func main() {
      http.HandleFunc("/create-hook", createHookHandler)
      log.Fatal(http.ListenAndServe(*httpListenAddress, nil))
}// createHookHandler est un gestionnaire http qui gérera les requêtes de webhook
func createHookHandler(w http.ResponseWriter, r *http.Request) {
       // analyser la charge utile json entrante
       whp := &whPayload{}
       err := json.NewDecoder(r.Body).Decode(whp)
       if err != nil {
               log.Println("Err : reçu un corps étrange sur le webhook