Chatbot a Facebook Messenger számára a párbeszédfolyamat és a node.js használatával: 1. rész.

Áttekintés

Itt felépítjük az egyszerű facebook messenger chatbotot a párbeszédfolyamat és a Node.js használatával. nem fogunk mélyen belemenni, de mindenféle választ, amelyet az üzenetküldő platform támogat, mint például egy általános sablont, nyugtát, gombot, adathordozót, listát és grafikonokat, lefedjük.

Előfeltétel

  • Facebook oldal
  • Facebook fejlesztői fiók
  • A Dialogflow megértése
  • A Node.js ismerete

Elkezdeni

Kezdjük azzal, hogy létrehozunk egy Facebook alkalmazást a Facebook fejlesztői fiókból.

A rendszer átirányítja az irányítópultra, innen adjon hozzá egy Messenger terméket

A beállítás után válassza ki a Facebook oldalát a Token Generation alkalmazásban, és innen generálja a Tokent.

Szerver beállítása

Egyszerű kiszolgáló létrehozása a node.js fájlban könnyű.

Keresse meg a kívánt mappát, ahol a projektet beállítani kívánja. Nyissa meg azt a mappát a terminálon, és futtassa az npm init programot. Ez előállítja a package.json fájlt.

Telepítenünk kell a függőségeinket, Futtassa az npm-t, i apiai axios body-parser express uuid –save

A függőségek telepítése után hozza létre az index.js fájlt, és importálja az éppen telepített függőségeket, és hozzon létre egy egyszerű expressz kiszolgálót. Készítsen egy config.js fájlt, hogy a jobb kódkezelés és a biztonság érdekében tárolhassuk a hitelesítő adatainkat abban a fájlban, vagy a config.js helyett env fájlt is létrehozhat.

Index.js

const apiai = igényelni („apiai”);
const express = megköveteli (“express”);
const bodyParser = igényelni (“test elemző”);
const uuid = igényelni (“uuid”);
const axios = igényelni ('axios');
// Config fájl importálása
const config = igényelni (“./fig”);
// a Port beállítása
app.set („port”, process.env.PORT || 5000);
// statikus fájlok kiszolgálása a nyilvános könyvtárban
app.use (express.static ( „public”));
// Alkalmazási folyamat / x-www-form-urlencoded
app.use (
bodyParser.urlencoded ({
kiterjesztett: hamis
})
);
// Folyamat alkalmazás / json
app.use (bodyParser.json ());
// Index útvonal
app.get (“/”, funkció (req, res) {
res.send (“Helló világ, chat-bot vagyok”);
});
// a Facebook ellenőrzéséhez
app.get (“/ webhook /”, funkció (req, res) {
console.log ( „kérelem”);
ha (
req.query [“hub.mode”] === “előfizetés” &&
req.query [“hub.verify_token”] === config.FB_VERIFY_TOKEN
) {
res.status (200) .send (req.query [ „hub.challenge”]);
} más {
console.error (“Sikertelen érvényesítés. Győződjön meg arról, hogy az érvényesítési tokenek megegyeznek.”);
res.sendStatus (403);
}
});
// Húzza fel a szervert
app.listen (app.get („port”), function () {
console.log (“Magic Started on port”, app.get (“port”));
});

Spin fel a szervert. Élővé kell tennünk a kommunikációt, így itt az ngrok-ot használjuk a localhost élővé tételéhez, de bármikor használhat bármilyen más platformot, például heroku, localtunnel vagy bármilyen más harmadik fél szolgáltatását.

Szerverünk élő típusának a ./ngrok http 5000 beírásához a terminálon, amely élő URL-t fog adni. De győződjön meg arról, hogy a fenti parancs futtatása közben letöltötte az ngrok fájlt a megfelelő operációs rendszerre. Az Ngrok fájlnak a jelenlegi munkakönyvtárban kell lennie a fenti parancs sikeres végrehajtásához.

Config.js

module.exports = {
FB_PAGE_TOKEN: “Page Access Token”,
FB_VERIFY_TOKEN: “Facebook ellenőrző kód a Webhookhoz”,
API_AI_CLIENT_ACCESS_TOKEN: “DialogFlow token”,
FB_APP_SECRET: “Facebook titkos kód”,
};

FB_PAGE_TOKEN: Másolja a létrehozott oldal-hozzáférési jogkivonatot, majd illessze be a config.js fájlba. FB_APP_SECRET: Az App Secret alkalmazást a Beállítások oldalon találja meg

Most kattintson a webhook beállítása elemre, és azt látja, hogy közvetlenül a tokengenerációs ablak alatt található. Illessze be a kiszolgáló URL-jét a végpont / webhook segítségével, és a Verify Token lehet bármi, és ellenőrizze az üzeneteket és az üzenetküldés visszajelzéseit.

Ha rákattint a Hitelesítés és Mentés elemre, akkor a GET ellenőrző kérést kap a Facebook-tól. (feltétlenül másolja a https: // URL-t)

FB_VERIFY_TOKEN: Illessze be az ellenőrző tokent a config.js fájlba. SERVER_URL: Másolja le az ngrok élő URL-jét, és illessze be.

Dialogflow integráció

Most konfiguráljuk a párbeszédfolyamatot a webhook kóddal. Adjon hozzá új ügynököt és válassza a v1 API-t, és másolja az ügyféllel való hozzáférési jogkivonatot, és illessze be az API_AI_CLIENT_ACCESS_TOKEN fájlba.

Hozzunk létre egy szándékot a párbeszédfolyamatban.

  1. Adjon hozzá egy szándékot a bal oldalsávból.
  2. Adjon egy szándékot: küldjön szöveget
  3. Add edzési mondatok: „Hé, küldjön nekem egy szöveges üzenet példáját” vagy releváns.
  4. Adja hozzá a művelet nevét: „küldjön szöveget”
  5. Mentsd el.
  6. Most tegye ugyanazt a képet-küldés, küldés-média, küldés-lista, küldés-nyugtázás, küldés-gyors válasz, küldés-grafikon, küldés-karusszelEllenőrizze, hogy megadja-e az egyedi műveletet minden szándékához. Meg kell határoznunk a felhasználó szándékát, hogy megfelelő választ küldjön a webhook szerverünkről.
  1. Kattintson a Teljesítés fülre, adja hozzá ide a webhook végpontját, és mentse el.
  1. Ennél a példánál semmi több a Dialogflow-ban.

Ha nem ismeri a párbeszédfolyamatot, kérjük, olvassa el a dokumentációt.

Térjünk vissza az index.js-hez, adjuk hozzá ezt a kódrészletet a Dialogflow-hoz való kapcsolódáshoz.

const apiAiService = apiai (config.API_AI_CLIENT_ACCESS_TOKEN, {
nyelv: „en”,
requestSource: “fb”
});
const sessionIds = új térkép ();

A Webhook végpont beállítása

Most, amikor a felhasználó üzenetet küld a facebookon, megkapjuk a post kérést a csomópont szerverünkön. Tehát kezelnünk kell ezt a / webhook végpontot.

/ *
* Az Messenger összes visszahívása POST-ed. Ugyanezek lesznek küldve
* webhook. Feltétlenül iratkozzon fel alkalmazására az oldalára, hogy visszahívásokat kapjon
* az Ön oldalához.
* https://developers.facebook.com/docs/messenger-platform/product-overview/setup#subscribe_app
*
* /
app.post (“/ webhook /”, funkció (req, res) {
var data = req.test;
// Győződjön meg arról, hogy ez egy oldal előfizetés
if (data.object == “oldal”) {
// Iratálj meg minden bejegyzést
// Számos lehet, ha csomagolva van
data.entry.forEach (függvény (pageEntry) {
var pageID = pageEntry.id;
var timeOfEvent = pageEntry.time;
// Iratálj meg minden üzenetküldési eseményt
pageEntry.messaging.forEach (funkció (messagingEvent) {
if (messagingEvent.message) {
receivedMessage (messagingEvent);
} más {
console.log („A Webhook ismeretlen üzenetküldési eseményt kapott:“, üzenetküldő esemény);
}
});
});
// Tegyük fel, hogy minden jól ment.
// 200 másodpercen belül vissza kell küldenie a 200-at
res.sendStatus (200);
}
});

Az Üzenetek, az Üzenetküldés_postacsomagolja ezt a két eseményt, amelyeket ellenőriztünk a webhook beállításakor. (nem itt használunk visszamenőleges eseményt) ReceiveMessage (messagingEvent) tegyük most ezt a funkciót,

funkció kapott üzenet (esemény) {
var senderID = event.sender.id;
var recipIDID = event.recipient.id;
var timeOfMessage = event.timestamp;
var üzenet = esemény.üzenet;
if (! sessionIds.has (senderID)) {
sessionIds.set (senderID, uuid.v1 ());
}
var messageId = message.mid;
var appId = message.app_id;
var metadata = message.metadata;
// Lehet, hogy szöveget vagy mellékletet kap, de nem mindkettőt
var messageText = message.text;
var messageAttachments = message.attachments;
if (messageText) {
// üzenet küldése az api.ai-nak
sendToApiAi (senderID, messageText);
} máshol, ha (messageAttachments) {
handleMessageAttachments (messageAttachments, senderID);
}
}

Ha vigasztalja az eseményt, akkor JSON-t fog kapni,

Egyelőre csak összpontosítson a sender.id és a What message.text elemre. Ha van messageText a kapottMessage () függvényben, akkor a sendToApiAi () -et hívjuk.

Ebben a funkcióban először hívjuk a sendTypingOn () -ot, hogy megmutassuk, hogy a bot gépelt-e a Messengerben.

sendToApiAi függvény (feladó, szöveg) {
sendTypingOn (küldő);
let apiaiRequest = apiAiService.textRequest (szöveg, {
sessionId: sessionIds.get (feladó)
});
apiaiRequest.on (“válasz”, válasz => {
if (isDefined (response.result)) {
handleApiAiResponse (feladó, válasz);
}
});
apiaiRequest.on (“hiba”, hiba => console.error (hiba));
apiaiRequest.end ();
}

Küldés gépelés be

A SendTyping felhívja a Facebookot, hogy API-t küldjön a gépelési művelet elküldéséhez.

/ *
* Kapcsolja be a gépelés-jelzőt
*
* /
const sendTypingOn = (recipiend) => {
var messageData = {
címzett: {
id: recipiend
},
Sender_action: “typing_on”
};
callSendAPI (messageData);
}

A callSendAPI () függvény elküldi az általunk generált üzenetadatokat. (itt küldjük a művelet gépelését)

/ *
* Hívja a Send API-t. Az üzenet adatai a testbe kerülnek. Ha sikeres, akkor mi is lesz
* válaszként kapja meg az üzenet azonosítóját
*
* /
const callSendAPI = async (messageData) => {
const url = “https://graph.facebook.com/v3.0/me/messages?access_token=” + config.FB_PAGE_TOKEN;
várjon axios.post (URL, messageData)
. majd (funkció (válasz) {
if (response.status == 200) {
var recipiend = response.data.recipient_id;
var messageId = response.data.message_id;
if (messageId) {
console.log (
"% S azonosító üzenet sikeresen elküldve a (z)% s címzettnek",
MessageID,
recipientId
);
} más {
console.log (
„A (z)% s címzett sikeres elküldése API küldésére”,
recipientId
);
}
}
})
.catch (függvény (hiba) {
console.log (error.response.headers);
});
}

Térjünk vissza a sendToApiAi () függvényre, azután isDefined () függvényt hívunk, hogy megbizonyosodjunk arról, hogy megfelelő választ kapunk-e.

const isDefined = (obj) => {
if (typeof obj == “meghatározatlan”) {
hamis visszaadást;
}
if (! obj) {
hamis visszaadást;
}
return obj! = null;
}

Ugyanebben a sendToApiAi () függvényben megkapjuk a választ a Dialogflow-ból JSON formátumban.

Küldje el ezeket az adatokat a handleApiAiResponse () fájlnak.

function handleApiAiResponse (feladó, válasz) {
hadd responseText = response.result.fulfillment.speech;
hadd responseData = response.result.fulfillment.data;
hagyja, hogy az üzenetek = response.result.fulfillment.messages;
hadd action = response.result.action;
hadd összefüggések = response.result.contexts;
hadd paraméterek = response.result.parameters;
sendTypingOff (küldő);
if (responseText == “” &&! isDefined (action)) {
// api ai nem tudta értékelni a bemenetet.
console.log (“Ismeretlen lekérdezés” + response.result.resolvedQuery);
sendTextMessage (
feladó,
- Nem tudom, mit akar. Lehetne kicsit pontosabban?"
);
} else if (isDefined (action)) {
handleApiAiAction (feladó, akció, responseText, összefüggések, paraméterek);
} else if (isDefined (responseData) && isDefined (responseData.facebook)) {
próbálja meg {
console.log (“Válasz formázott üzenetként” + responseData.facebook);
sendTextMessage (feladó, responseData.facebook);
} fogás (hibás) {
sendTextMessage (feladó, hibaüzenet);
}
} else if (isDefined (responseText)) {
sendTextMessage (feladó, responseText);
}
}

Küldje el a gépelést

Emlékezik? elkezdtük a Messenger gépelését a Messenger-en, most már válaszunk van arra, hogy kikapcsoljuk, hívjuk a sendTypingOff () függvényt.

/ *
* Kapcsolja ki a gépelés-jelzőt
*
* /
const sendTypingOff = (recipiend) => {
var messageData = {
címzett: {
id: recipiend
},
Sender_action: “typing_off”
};
callSendAPI (messageData);
}

Szöveges üzenet küldése

Ha bármikor ismeretlen lekérdezést kapunk a felhasználótól, akkor alapértelmezett üzenetet kell küldenünk a felhasználónak.

const sendTextMessage = async (recipienta azonosító, szöveg) => {
var messageData = {
címzett: {
id: recipiend
},
üzenet: {
szöveg: szöveg
}
};
várja meg a callSendAPI-t (messageData);
}

A fenti funkció felhívja a facebook send API-t, és elküldi a szöveges üzenetet, amelyet alapértelmezésként definiáltunk.

Most, ha a felhasználó szándéka párosul a párbeszédfolyamattal, akkor megkapjuk a szándékunk műveletét (egy olyan műveletet, amelyet a párbeszédfolyamat válaszából kapunk), azon tevékenység alapján, amelyet minden felhasználónak elküldünk.

Amikor egy felhasználó megkérdezi: „Küldj nekem egy szöveges üzenet példáját” -> a „send-text” szándékunk felhívásra kerül, és szándékunk alapján megkapjuk az egyedi műveletét. Az én esetemben ugyanazt a műveleti nevét adtam, mint a szándék nevét.

Ha a műveletet a párbeszédfolyamat válaszából kapjuk, akkor a HandApiAiAction () hívásra hívjuk.

function handleApiAiAction (feladó, akció, responseText, összefüggések, paraméterek) {
kapcsoló (akció) {
„send-text” eset:
var responseText = “Ez a szöveges üzenet példája.”
sendTextMessage (feladó, responseText);
szünet;
alapértelmezett:
// nem kezelt művelet, csak küldje vissza a szöveget
sendTextMessage (feladó, responseText);
}

Eredetileg a www.yudiz.com webhelyen tették közzé.

Írta: Nikhil Savaliya