Slack ist ein beliebtes Tool, um eine bessere Kommunikation zwischen Teammitgliedern zu fördern. Es verfügt über eine Reihe hilfreicher Funktionen und Dienste, einschließlich Integrationen von Drittanbietern und Unterstützung von Webhook. Slack Webhooks können lustig und nützlich sein und sie sind einfach eingerichtet. In diesem Tutorial richten wir einen einfachen Server mit Node.js und Heroku ein, der auf die Nachrichten Ihres Teams von Slack als "Bot" reagiert. Die Vertrautheit mit JavaScript und Git wird hilfreich sein. Wenn Sie Git noch nie benutzt haben, werfen Sie einen Blick auf Git, damit Anfänger loslegen können. Der Zugriff auf ein Slack -Konto wird ebenfalls angenommen, aber keine Sorge - sie sind kostenlos!
Erstellen eines Webservers
Erstellen Sie ein neues Verzeichnis für Ihre App und führen Sie NPM Init aus, um Ihre Paket.json -Datei zu generieren. In Ihrem Paket.json-Abhängigkeiten "Express" enthalten: "^4.x.x" und "Body-Parser": "^1.x.x". Das Body-Parser-Paket wird verwendet, um die von Slack gesendete Nutzlast zu analysieren. Erstellen Sie die Serverdatei mit dem Namen app.js. Hier benötigen wir die erforderlichen Module, fügen Sie die Middleware von Body Parser, den Fehlerhandler und eine Testroute hinzu. Dann sagen wir dem Server, er soll anfangen zuzuhören.
<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span> <span>console.error(err.stack);
</span> res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span> <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>Führen Sie den Server mit der Knoten -App aus und überprüfen Sie, ob Sie http: // localhost: 3000 mit „Hallo Welt!“ Antworten.
Erstellen Sie eine Datei namens Hellobot.js
Dieses Modul wird dort sein, wo unser Bot -Logik lebt. Es wird eine exportierte Funktion enthalten, die eine Nachricht an Slack mit dem Statuscode 200 zurückgibt. Wir werden zunächst die Daten analysieren, die Slack an unseren Server sendet, und dann mit einer ordnungsgemäß formatierten Nutzlast unserer eigenen antworten. Lassen Sie uns dazu unseren ausgehenden Webhook unter konfigurierten Integrationen erneut besuchen. Das Beispiel für ausgehende Daten zeigt uns alle Informationen, die Slack sendet, wenn ein Outoing -Webhook ausgelöst wird.
Sie können sehen, dass einige der Daten zur Authentifizierung oder Routing nützlich sein können, aber im Moment konzentrieren wir uns nur auf die Eigenschaft user_name. Mit diesem Wert können wir einen personalisierten Gruß an den Benutzer zurücksenden.
module<span>.exports = function (req<span>, res, next</span>) {
</span> <span>var userName = req.body.user_name;
</span> <span>var botPayload = {
</span> <span>text : 'Hello, ' + userName + '!'
</span> <span>};
</span>
<span>// avoid infinite loop
</span> <span>if (userName !== 'slackbot') {
</span> <span>return res.status(200).json(botPayload);
</span> <span>} else {
</span> <span>return res.status(200).end();
</span> <span>}
</span><span>}</span>Hier erstellen wir unser BotPayload -Objekt. Die einzige notwendige Eigenschaft ist botpayload.text, die definiert, was unser Bot bei der Reaktion anzeigen wird. Fügen Sie die Texteigenschaft mit einer Begrüßung dem Benutzer hinzu und antworten Sie mit JSON und einem Statuscode von 200. Beachten Sie, dass die Antwort unseres Bots unser ausgehender Webhook -Trigger -Wort ist! Um eine unendliche Schleife zu vermeiden, können wir den Benutzer des Körpers überprüfen. Alle Hooks posten als "Slackbot", auch wenn der Name im Chat anders angezeigt wird. Wir können diese Tatsache verwenden, um zu verhindern, dass unser Haken auf sich selbst reagiert.
Zurück in App.js benötigen das Bot -Modul oben.
<span>var hellobot = require('./hellobot');</span>Fügen Sie dann eine Route hinzu, die einen Beitrag zu /Hallo hört.
app<span>.post('/hello', hellobot);</span>Lassen Sie uns einen kurzen Test durchführen. Führen Sie die App erneut mit der Knoten -App aus und stellen Sie in einem anderen Terminalfenster Curl, um sicherzustellen, dass die App so reagiert, wie wir es erwarten. (Hinweis: Da unser Bot hier nur nach einem Wert sucht, müssen die gesamte Slack -Nutzlast in unserem Test nicht aufgenommen werden.
curl -X POST --data "user_name=foobar" http://localhost:3000/hello
Wenn unsere App funktioniert, sollten wir eine Antwort sehen, die so aussieht:
<span>{"text":"Hello, foobar!"}</span>Jetzt ist es Zeit, unseren Bot online zu stellen.
Heroku ist ein bequemer Dienst, mit dem Sie in sehr wenig Zeit kostenlos online online erhalten können. Bereitstellungen werden erstellt, indem Ihr Code auf den Git -Server weitergegeben wird, auf dem er automatisch bereitgestellt und ausgeführt wird. Erstellen Sie ein Konto auf Heroku oder melden Sie sich an, wenn Sie bereits ein Konto haben.
Sobald Sie sich angemeldet haben, sehen Sie Ihr Heroku -Dashboard. Klicken Sie oben rechts, um eine neue App zu erstellen. Befolgen Sie die Anweisungen, um sich bei Heroku auf Ihrem Computer anzumelden. Die Bereitstellung ist einfach, aber es gibt viel zu wissen, wenn Sie eine App zum ersten Mal bereitstellen. Stellen Sie sicher, dass Sie diesem Handbuch folgen, wenn Sie Ihre App einrichten. Wir werden auf dem Weg einige doppelte Überprüfungen durchführen, aber es gibt viele gute Informationen, die außerhalb des Rahmens dieses Artikels liegen.
Bevor wir unseren Bot bereitstellen können, müssen wir Heroku sagen, wie die App ausgeführt werden soll. Dies geschieht durch Erstellen einer Procfile. Ihr Procfile braucht nur eine einzige Zeile:
<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span> <span>console.error(err.stack);
</span> res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span> <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>Sobald Sie dies getan haben, können Sie Ihre Änderungen begehen und nach Heroku drängen. Heroku installiert automatisch die Knotenmodule und Sie werden die Ergebnisse Ihrer Bereitstellung angezeigt. Wenn alles reibungslos verlief, sehen Sie unten einen Link zu Ihrer App. Kopieren Sie diese URL und besuchen Sie die Konfigurationsseite Ihres ausgehenden Webhooks erneut. Fügen Sie die URL hinzu, die Sie mit der angehängten URL -Eingabefeld kopiert haben, und ändern Sie den Namen und das Symbol des Hakens, wenn Sie möchten.
Es gibt noch einen Schritt, um den Bot online zu machen: Wir müssen ihm einen Dyno geben. Geben Sie im Terminal:
einmodule<span>.exports = function (req<span>, res, next</span>) {
</span> <span>var userName = req.body.user_name;
</span> <span>var botPayload = {
</span> <span>text : 'Hello, ' + userName + '!'
</span> <span>};
</span>
<span>// avoid infinite loop
</span> <span>if (userName !== 'slackbot') {
</span> <span>return res.status(200).json(botPayload);
</span> <span>} else {
</span> <span>return res.status(200).end();
</span> <span>}
</span><span>}</span>Dies fordert Heroku auf, Ihrer App einen Webarbeiter zu geben. Vorsichtig; Ihre App erhält nur einen kostenlosen Dyno pro Monat!
Ihr Bot sollte jetzt online sein. Gehen Sie also wieder in Slack und testen Sie ihn aus!
Wenn Sie keine Antwort erhalten haben, gehen Sie zurück und überprüfen Sie Ihren Code. Sie können die Terminalbefehlsbefehl Heroku -Protokolle verwenden, um Details zu den Anfragen sowie zu jeder Konsole (log ()) anzuzeigen, die Sie hinzugefügt haben.
Nicht zu schwierig, oder? Wir haben erfolgreich einen Webhook in Slack eingerichtet, unsere App für Heroku bereitgestellt und die beiden miteinander sprechen! Ein bisschen mehr Arbeit als ein einfaches Programm „Hello World“, aber viel lohnender. Nachdem wir unseren Server ausgeführt haben, können wir problemlos mehr Hooks und Antworten hinzufügen. Hellobot ist ziemlich freundlich, aber es ist nicht so nützlich. Im nächsten Abschnitt verwenden wir die anderen Webhook -Typen von Slack, um einen Dice Roll -Chat -Befehl zu erstellen.
Im letzten Abschnitt haben wir einen ausgehenden Webhook verwendet, der Chat für ein Triggerwort hörte, eine Nachricht an unseren Server gesendet und die Antwort angezeigt wurde. In diesem Abschnitt werden zwei weitere Tools zum Erstellen benutzerdefinierter Integrationen verwendet: Slash -Befehle und eingehende Webhooks. Besuchen Sie die Seite "Integrationen" und sehen Sie sich die anderen Optionen unter DIY -Integrationen und -anpassungen an. Beginnen wir zunächst die Integration von Slash -Befehlen hinzufügen. Lesen Sie die kurze Beschreibung, setzen Sie den Befehl auf "/rollen" und fügen Sie die Integration hinzu. Die nächste Seite zeigt die Konfiguration. Sie können sehen, dass die ausgehenden Daten dem ausgehenden Webhook, den wir zuvor konfiguriert haben, ähnlich aussehen. Wir werden die App verwenden, die wir im letzten Abschnitt für diesen Abschnitt erstellt haben, damit wir dieselbe URL verwenden können. Diesmal werden wir jedoch auf die Route /die Route veröffentlichen.
Beachten Sie, dass die Integration des Slash -Befehls auf den Benutzer reagieren kann, jedoch nur im privaten. Welche Würfelbrötchen verwenden, wenn Sie nur die Würfel sehen können? Slack schlägt vor, einen eingehenden Webhook zusammen mit Slash -Befehlen zu verwenden, um Nachrichten an Chat zu senden. Gehen Sie zurück zur Seite Konfigurieren Integrationen und fügen Sie einen eingehenden Webhook hinzu. Lesen Sie die Beschreibung, wählen Sie einen Kanal aus und fügen Sie den Haken hinzu. Mach dir keine Sorgen darüber, welchen Kanal du ausgewählt hast. Wir können den Kanal in der Antwort unseres Bots angeben. Da wir den Kanal in unserer App auswählen können, können wir diese Integration auch für alle anderen Bots verwenden, die wir erstellen. Das eingehende Webhook hat nicht viel Konfiguration, enthält jedoch viele wichtige Informationen, um die Antwortnutzlasten unseres Bots zu erstellen. Der wichtigste Teil ist die Webhook -URL. Wir werden dies von unserer App aus veröffentlichen, um Nachrichten an Slack zu senden.
Da wir unseren Slash -Befehl auf der Route /Rolle hingewiesen haben, können wir diese Route neben Hellobot hinzufügen. Wir werden eine geheime URL für unseren eingehenden Haken verwenden. Daher ist es eine gute Idee, sie versteckt zu halten, falls Sie Ihren Code öffentlich machen möchten. Eine gute Möglichkeit, dies zu tun, besteht darin, Herokus Konfigurationsvars zu verwenden.
Fügen wir unserem Paket auch Anfrage hinzu, um sie mit dem eingehenden Haken zu verwenden:
<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span> <span>console.error(err.stack);
</span> res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span> <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>Jetzt fügen wir dicebot.js hinzu. Dicebot wird eine Funktion exportieren, aber wir benötigen zwei zusätzliche Funktionen: eine, die in den eingehenden Webhook veröffentlichen kann, und einen, um die Würfel zu rollen.
module<span>.exports = function (req<span>, res, next</span>) {
</span> <span>var userName = req.body.user_name;
</span> <span>var botPayload = {
</span> <span>text : 'Hello, ' + userName + '!'
</span> <span>};
</span>
<span>// avoid infinite loop
</span> <span>if (userName !== 'slackbot') {
</span> <span>return res.status(200).json(botPayload);
</span> <span>} else {
</span> <span>return res.status(200).end();
</span> <span>}
</span><span>}</span>Wie viele Tabletop-Spieler wissen, gibt es viel mehr Arten von Würfel als nur sechsseitige Würfel. Andere Würfel haben vier Seiten, acht Seiten, zehn Seiten, zwanzig Seiten und vieles mehr! Eine spezielle Notation wird beim Rollen dieser Würfel verwendet:
Beginnen wir zunächst einige Variablen initialisieren und die Eingabe analysieren. Wir setzen einige Standardwerte fest, falls der Benutzer Eingaben weglassen möchte.
<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span> <span>console.error(err.stack);
</span> res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span> <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>Der regelmäßige Ausdruck oben ist ziemlich zuverlässig für die Parsen von Würfelnrollen und beschränkt die Werte nur auf zweistellige Zahlen, damit der Benutzer nicht verrückt werden kann. Wenn der Benutzer seine Syntax durcheinander gebracht hat, senden wir einen Hinweis zurück.
Das Würfeln mit dem Benutzereingang ist einfach genug. In diesem Thread finden Sie eine Erklärung, wie eine zufällige Rolle funktioniert. Für wirklich zufällige Rollen können Sie sich an die Random.org -API wenden. Schreiben wir die Rollfunktion.
module<span>.exports = function (req<span>, res, next</span>) {
</span> <span>var userName = req.body.user_name;
</span> <span>var botPayload = {
</span> <span>text : 'Hello, ' + userName + '!'
</span> <span>};
</span>
<span>// avoid infinite loop
</span> <span>if (userName !== 'slackbot') {
</span> <span>return res.status(200).json(botPayload);
</span> <span>} else {
</span> <span>return res.status(200).end();
</span> <span>}
</span><span>}</span>In unserer Hauptfunktion werden wir dann einige Rollen erstellen und eine Nachricht erstellen, mit der sie antworten können. Fügen wir den Namen der Walze hinzu, damit andere Benutzer sehen können, wer den Befehl /roll verwendet.
<span>var hellobot = require('./hellobot');</span>Wir haben die Nachricht zur Eigenschaft botpayload.text hinzugefügt, wobei einige Slack -Formatierung insgesamt umsetzt werden, um sie fett zu machen. Wir können auch den Namen, das Symbol und den Kanal mit der Antwortnutzlast konfigurieren. Wir setzen den Kanal basierend auf dem Kanal. Der Benutzer gibt den Befehl rollen aus. Slack schlägt vor, den Namen des Kanals in der Nutzlast zu verwenden, aber das bedeutet, dass wir ihn mit "#" vorbereiten müssen. Stattdessen können wir die Kanal -ID verwenden, mit der wir sowohl in öffentlichen Kanälen als auch in privaten Gruppen veröffentlichen können. Für das Symbol gibt
app<span>.post('/hello', hellobot);</span>In unserer Hauptfunktion werden wir die Send -Anfrage einleiten. Wenn es funktioniert, können wir auf den Slash -Befehl mit leerem Jahr reagieren. Wenn nicht, können wir die Werte aus unserem SEND () -Rückruf verwenden, um einen Fehler zu erstellen. Dadurch wird der Fehlerhandler in app.js ausgelöst und 400 zurückversetzt, wodurch der Benutzer über den Fehler informiert wird.
curl -X POST --data "user_name=foobar" http://localhost:3000/hello
Lassen Sie uns unseren Server ausführen und ihn erneut abrufen. Dieses Mal müssen wir den Channel_ID einbeziehen. Sie können den Slack -API -Tester verwenden, um den richtigen Channel_ID zu finden. Da das eingehende Webhook bereits eingerichtet wurde, sollte es unseren Server anrufen hören. Wir müssen auch den eingehenden Webhook -Pfad in unserer Umgebung aufnehmen, da die App noch nicht auf Heroku ist.
<span>{"text":"Hello, foobar!"}</span>
web: node app
heroku ps:scale web=1
sieht gut aus! Lassen Sie es uns bereitstellen.
Neueinstellung nach Heroku
Verwenden Sie dann Git, um die neuen Dateien hinzuzufügen, Ihre Änderungen zu verpflichten und zu Ihrer Heroku -Fernbedienung zu treiben. Heroku installiert Knotenmodule und startet den Server. Bevor wir es testen, schauen wir uns die Protokolle in Echtzeit an:
Heroku Protokolle -t
Wenn unsere Hooks alle eingerichtet sind, sollte unser Rollbefehl bereit sein. Probieren Sie ein paar Brötchen aus! Wenn etwas nicht funktioniert hat, können Sie die Heroku -Protokolle zum Debuggen verwenden. Um die vollständige App in seiner Gesamtheit anzuzeigen, lesen Sie dieses Github -Repo.
Diese beiden Bots zeigen alle Tools, die Sie benötigen, um Ihre eigenen Chat -Bots und -integrationen zu schreiben. Sie können viele Dienste in Bots integrieren oder versuchen, einen überzeugenden Gesprächspartner zu machen. API- und Knotenmodule existieren für Sie, um beide Ziele zu erreichen.
Einige andere Ideen für Bots:
Wenn Sie gute Ideen finden, teilen Sie Ihren Code! Bots machen Spaß zu machen, und sie waren nie einfacher zu erstellen.
Welche nützlichen Funktionen können ich meinem Slack -Bot hinzufügen? auf was Sie wollen. Sie können Ihren Bot beispielsweise so programmieren, dass Sie auf bestimmte Befehle oder Schlüsselwörter antworten, geplante Nachrichten senden oder sogar in andere APIs integrieren, um Daten aus externen Quellen zu ziehen. Sie können auch interaktive Elemente wie Schaltflächen oder Dropdown -Menüs zu den Nachrichten Ihres Bots hinzufügen.
Kann ich meinen Slack -Bot in andere Dienste integrieren? Bot mit anderen Diensten. Slack bietet eine Vielzahl von APIs und Funktionen, mit denen Sie sich in externe Dienste integrieren können. Zum Beispiel können Sie eingehende Webhooks verwenden, um Daten aus anderen Diensten zu empfangen oder Webhooks auszubleiben, um Daten an andere Dienste zu senden. Fehler in Ihrem Slack -Bot mithilfe von Fehlerbehandlungstechniken in Ihrer Programmiersprache. In JavaScript können Sie beispielsweise versuchen, Fehler zu fangen und zu behandeln. Sie können auch das Fehlerereignis verwenden, um auf Fehler zu hören, die während des Ausführens Ihres Bots auftreten. Dein lockerer Bot. Sie können ein benutzerdefiniertes Symbol und einen benutzerdefinierten Namen für Ihren Bot festlegen, wenn Sie es erstellen. Sie können auch das Erscheinungsbild der Nachrichten Ihres Bots mithilfe von Anhängen oder Blöcken anpassen, mit denen Sie Farbe, Bilder und andere Formatierung hinzufügen können. 🎜> Sie können die Sicherheit Ihres Slack -Bots sicherstellen, indem Sie Best Practices für die Botentwicklung befolgen. Dies beinhaltet, dass Ihr Bot -Benutzer OAuth Access -Token geheim bleibt und es nicht mit jemandem geteilt hat. Sie sollten auch alle Daten validieren, die Ihr Bot erhält, um sicherzustellen, dass sie von einer vertrauenswürdigen Quelle stammen. Darüber hinaus sollten Sie den Code Ihres Bots regelmäßig aktualisieren, um alle Sicherheitslücken zu beheben.
Das obige ist der detaillierte Inhalt vonErste Schritte mit Slack Bots. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
So überprüfen Sie den Videospeicher von Win11
Eou Web3 Wallet-Tutorial
So stellen Sie den PPT-Breitbildmodus ein
Wie wäre es mit der MEX-Börse?
So beheben Sie den 504-Fehler im CDN
Verwendung von strncpy
Selbststudium für Anfänger in C-Sprache ohne Grundkenntnisse
Befehl zur Paketerfassung unter Linux
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
