Senden von Sprachbenachrichtigungen

Ein Telefonanruf ist eine Methode mit hoher Priorität für die Übermittlung wichtiger Warnmeldungen. In dieser Anleitung erfahren Sie, wie Sie Sprachbenachrichtigungen an eine Liste von Empfängern automatisieren, eine benutzerdefinierte Nachricht abspielen und die Bestätigung des Benutzers über die Tastatur (DTMF) erfassen können.

Voraussetzungen

• A Vonage-Konto
• Node.js auf Ihrem Rechner installiert.
• ngrok auf Ihrem Rechner installiert.

Initialisieren Sie Ihren Projektordner

1. Erstellen Sie die Umgebung, in der Ihr Code und Ihre Sicherheitsschlüssel gespeichert werden sollen.
2. Öffnen Sie Ihr Terminal und erstellen Sie ein neues Verzeichnis:

3. Initialisieren Sie das Projekt und installieren Sie das Vonage SDK und Express:

Lokalen Server freilegen

Vonage needs to send webhooks to your local machine. Use ngrok to expose your server:

ngrok will forward your local port 3000 to a public URL like https://{random-id}.ngrok.app.

Copy this URL. You’ll need it when configuring your Vonage application in the next step.

Erstellen einer Vonage-Applikation

Generieren Sie Ihre Anmeldedaten über das Dashboard und speichern Sie sie in dem soeben erstellten Ordner.

1. Melden Sie sich beim Vonage Dashboard an.

2. Gehe zu Applications > Erstellen einer neuen Anwendung.

3. Authentifizierung: Klicken Sie auf Öffentliche und private Schlüssel generieren.

   • Eine Datei namens private.key herunterladen wird.
   • Verschieben Sie diese private.key voice-notifications Ordner.

4. Fähigkeiten: Aktivieren Sie Sprache.

5. Legen Sie in den Spracheinstellungen die folgenden Webhooks fest:

   • Antwort-URL: https://{random-id}.ngrok.app/answer (Methode:
     GET
     )
   • URL der Veranstaltung: https://{random-id}.ngrok.app/event (Methode:
     POST
     )

6. Klicken Sie auf Änderungen speichern am unteren Ende.

Erstellen Sie den Webhook-Server (server.js)

Wenn Vonage einen Anruf entgegennimmt, holt es eine Objekt zur Anrufsteuerung (NCCO) von Ihrem answer_url. Dieses JSON-Array definiert das "Skript", dem der Aufruf folgt. Erstellen Sie eine Datei namens server.js und richten Sie den Webhook ein, um das NCCO bereitzustellen:

const express = require('express');
const app = express();
app.use(express.json());

app.get('/answer', (req, res) => {
  // NCCO defines what the recipient hears
  res.json([
    {
      action: 'talk',
      text: 'This is a priority notification. Please press 1 to confirm receipt.'
    },
    {
      action: 'input',
      type: [ 'dtmf' ],
      dtmf: { maxDigits: 1 }
    }
  ]);
});

app.post('/event', (req, res) => {
  // Capture the button press
  if (req.body.dtmf && req.body.dtmf.digits === '1') {
    console.log(`✅ Confirmation received from UUID: ${req.body.uuid}`);
  }
 if (status) {
    console.log(`Call Status Update: ${status} (UUID: ${req.body.uuid})`);
  }
  res.status(204).send();
});

app.listen(3000, () => console.log('🚀 Webhook server listening on port 3000'));

Erstellen Sie das Broadcast-Skript (broadcast.js)

Erstellen Sie eine Datei mit dem Namen broadcast.js. Dieses Skript löst die ausgehenden Anrufe aus.

const { Vonage } = require('@vonage/server-sdk');

// --- 1. CONFIGURATION ---
const API_KEY = "YOUR_API_KEY";
const API_SECRET = "YOUR_API_SECRET";
const APP_ID = "YOUR_APP_ID";
const VONAGE_NUMBER = "YOUR_VONAGE_NUMBER";
const TUNNEL_URL = "https://{random-id}.ngrok.app" // From the ngrok step above

// --- 2. PLACEHOLDER PROTECTION ---
const config = { API_KEY, API_SECRET, APP_ID, VONAGE_NUMBER, TUNNEL_URL };
Object.keys(config).forEach(key => {
    if (config[key].includes("YOUR")) {
        console.error(`❌ ERROR: The ${key} placeholder has not been updated!`);
        process.exit(1);
    }
});

const vonage = new Vonage({
  apiKey: API_KEY,
  apiSecret: API_SECRET,
  applicationId: APP_ID,
  privateKey: './private.key'
});

const recipients = [
  { name: 'Alice', number: '15551234567' }
];

async function broadcast() {
  for (const person of recipients) {
    try {
      const result = await vonage.voice.createOutboundCall({
        to: [{ type: 'phone', number: person.number }],
        from: { type: 'phone', number: VONAGE_NUMBER },
        answer_url: [`${TUNNEL_URL}/answer`],
        event_url: [`${TUNNEL_URL}/event`]
      });
      console.log(`☎️  Calling ${person.name}... (UUID: ${result.uuid})`);
    } catch (err) {
      console.error(`❌ Failed to call ${person.name}:`, err.message);
    }
  }
}

broadcast();

Testen Sie Ihre Benachrichtigung

1. Starten Sie Ihren Server: Führen Sie aus. node server.js in Ihrem Projektordner.
2. Starten Sie die Übertragung: Führen Sie in einem separaten Terminal Folgendes aus node broadcast.js. Ihr Telefon klingelt, spielt die Nachricht ab und protokolliert Ihre Bestätigung an der Konsole, wenn Sie die "1" drücken.

Nächste Schritte

Anpassungen: Ändern Sie Text-to-Speech Stimme oder verwenden Sie die Strom Aktion in Ihrem NCCO, um voraufgezeichnete MP3-Dateien anstelle von Text-to-Speech abzuspielen.

Sprach-KI: Hören Sie die Antwort des Empfängers mit Sprache-zu-Text oder verbinden Sie einen Sprachbot mit WebSocket.

Anrufbeantworter: Verwenden Sie Anrufbeantworter-Erkennung um eine Voicemail-Nachricht zu hinterlassen.

Skalierbarkeit: Für große Listen sollten Sie ein Warteschlangensystem einrichten, um die Vonage Raten-Grenzwerte.