Löschen von Firmengesprächsaufzeichnungen / On-Demand-Gesprächsaufzeichnungen nach Dauer

In diesem Tutorial lernen Sie, wie Sie eine Liste von Anrufaufzeichnungen nach einer bestimmten Dauer erhalten. Dies wäre nützlich, wenn Sie viele Anrufe haben, die sehr kurz sind (< 30 Sekunden) und gelöscht werden können. Dies würde bei der Erstellung von Berichten helfen, um Anrufe zu entfernen, die wenig oder keine Bedeutung für den Bericht haben. Oder Sie können auf diese Weise Anrufaufzeichnungen entfernen, um Geld für Anrufarchive zu sparen.

Mit der Anrufaufzeichnungs-API können Sie alle Anrufaufzeichnungen abrufen und nach Anrufdatum, Durchwahl, Anrufer_id, Richtung (eingehend oder ausgehend) und mehr filtern. Bitte schauen Sie sich die API-Referenz an, um alle möglichen Filter zu sehen.

In diesem Beispiel werden wir die Aufzeichnungen des letzten Monats abfragen und Anrufe löschen, die weniger als 30 Sekunden lang sind. Wir werden ein Python-Skript verwenden, um die Anrufaufzeichnungen abzufragen, und für jede Aufzeichnung werden wir die Aufzeichnung löschen.

Für die Erstellung des folgenden Beispiels wird Python verwendet; Sie können jedoch jede Sprache verwenden, mit der Sie am besten vertraut sind. Die folgende Python-Bibliothek wird verwendet in dieses Beispiel.

Voraussetzungen

Bevor Sie loslegen können, benötigen Sie einen Vonage Developer Account. Wenn Sie noch keinen Vonage Developer Account haben, verwenden Sie bitte diesen Leitfaden um Ihren Account einzurichten und zu erstellen.

Nachdem Sie einen Account eingerichtet haben, müssen Sie die folgenden Schritte anhand dieser Anleitungen durchführen:

Für dieses Beispiel müssen Sie sich bei der Anrufaufzeichnung API.

Authentifizierung

Nachdem Sie eine Anwendung erstellt und die Anrufaufzeichnungs-API abonniert haben, müssen Sie sich nun mit Ihren Anmeldedaten für Vonage Business Communications anmelden. Diese Beispielanwendung verwendet die Requests-Bibliothek zum Aufrufen der /api/accounts/ API. Sehen Sie sich die Anleitung zur Erstellung einer API-Anfrage für weitere Einzelheiten.

Als nächstes erstellen wir eine Funktion, die die /api/accounts API, um ein Zugriffs-Token zu generieren.

def get_token():
  url = "https://api.vonage.com/token"
  payload = 'grant_type=password&username={}&password={}&client_id={}&client_secret={}'.format(USERNAME, PASSWORD, CLIENT_ID, SECRET)
  headers = {
    'Content-Type': 'application/x-www-form-urlencoded'
  }

  response = requests.request("POST", url, headers=headers, data = payload)
  return response.json()

Um diese Funktion auszuführen, müssen Sie die folgenden Angaben machen:

  • USERNAME - Vonage Business Communications-Benutzername. Stellen Sie sicher, dass Sie Folgendes anhängen @vbc.prod zum Benutzernamen. firstname.lastname@vbc.prod.
  • PASSWORD - Passwort für Vonage Business Communications.
  • CLIENT_ID - Die Client-ID Ihrer Vonage Developer-Anwendung.
  • SECRET - Das Geheimnis Ihrer Vonage Developer-Anwendung.

Nachdem Sie diese Funktion ausgeführt haben, sollten Sie die folgende Antwort erhalten:

{'access_token': 'abc123-xxxxx-xxxxx',
'expires_in': 9999,
'refresh_token': 'def456-xxxx-xxxx',
'scope': 'default',
'token_type': 'Bearer'}

Anrufaufzeichnungen abrufen

Bevor wir die API company_call_recordings aufrufen, müssen wir einen Datumsstring übergeben, der einen Monat in der Vergangenheit liegt.

import datetime
import urllib.parse
today = datetime.datetime.now()
last_week = datetime.timedelta(days = 30)
date_diff = today - last_week
encoded_date = urllib.parse.quote_plus(date_diff.strftime('%Y-%m-%dT00:00:00+0000'))

Hier erhalten wir das aktuelle Datum mit datetime.datetime.now()verwenden, dann datetime.timedelta() Funktion, um ein Datum zu erstellen, das days in der Vergangenheit. Hier verwenden wir 30. Als Nächstes subtrahieren wir das aktuelle Datum vom Datum, das 30 Tage zurückliegt, um unser Datum zu erhalten. Schließlich verwenden wir strftime() um das Datumsobjekt in eine Zeichenkette zu konvertieren. Wir haben die Zeit auf 00:00:00+0000was bedeutet, dass wir das Datum um Mitternacht UTC erhalten. Bevor wir das Datum an die API für Anrufaufzeichnungen weitergeben können, müssen wir das Datum mit der folgenden Methode urlencodieren urllib.parse.quote_plus().

Als Nächstes fordern wir die Anrufaufzeichnungs-API an und verwenden die access_token die von der get_token() Funktion. Diese gibt eine JSON-Antwort mit den Anrufaufzeichnungen zurück. Wir geben dann das Datum ein encoded_date in diese Funktion

import requests
comany_recordings = []
def company_call_recordings(token, start_date, account_id="self",order="asc", page_size=10, page=1):
  url = "https://api.vonage.com/t/vbc.prod/call_recording/v1/api/accounts/{}/company_call_recordings?order={}&page_size={}&page={}&start:gte={}".format(account_id, order, page_size, page, start_date)
  headers = {
    'Accept': 'application/json',
    'Authorization': 'Bearer {}'.format(token),
  }

  response = requests.request("GET", url, headers=headers).json()
  if "_embedded" in response:
    comany_recordings.extend(response["_embedded"]["recordings"])

  if "total_pages" in response:
    if page < response["total_pages"]:
      page = page + 1
      company_call_recordings(token, start_date, account_id, order, page_size, page)

  return comany_recordings

Hier rufen wir die company_call_recordings/v1/api/ und übergibt die folgenden Parameter:

  • account_id - Die Account-ID für Vonage Business Communications. Sie können verwenden self um auf den Account des authentifizierten Benutzers zu verweisen.
  • page - Die Anzahl der anzufordernden Seiten.
  • page_size - Die angeforderte Seitengröße.
  • order - Die Reihenfolge der zurückgesendeten Gesprächsaufzeichnungen
  • start:gte - Datensätze nach Startdatum filtern (größer oder gleich)

Wir könnten auch in start:lte die Datensätze zurückgeben würde, die jünger als das angegebene Datum sind.

Sobald wir eine Liste von Gesprächsaufzeichnungen haben, gehen wir in einer Schleife durch jede Aufzeichnung und ermitteln die Dauer des Gesprächs. Wenn die Gesprächsdauer weniger als oder gleich 30 Sekunden beträgt, werden wir sie löschen. Vergewissern Sie sich vorher, dass Sie eine Sicherungskopie der Aufzeichnungen haben. Werfen Sie einen Blick auf die Aufzeichnungen nach Datum löschen Anwendungsfall, um Aufnahmen in Amazon S3 zu speichern.

Anrufaufzeichnungen löschen

Die get_company_call_recordings() gibt eine Liste der Aufnahmen des Accounts zurück. Als Nächstes erstellen wir eine Funktion zum Löschen der Aufnahme anhand der Aufnahme-ID.

def delete_call_recording(token, call_id, account_id="self"):
  url = "https://api.vonage.com/t/vbc.prod/call_recording/v1/api/accounts/{}/company_call_recordings/{}".format(account_id, call_id)

  headers = {
    'Accept': 'application/json',
    'Authorization': 'Bearer {}'.format(token)
  }

  response = requests.request("DELETE", url, headers=headers)
  return response

Diese Funktion übernimmt die Aufnahme aus dem call_id und löscht die Anrufaufzeichnung. Für dieses Beispiel setzen wir account_id zu self.

Als Nächstes durchlaufen wir die Anrufaufzeichnungen aus dem get_company_call_recordings() Funktion, die wir geschrieben haben, und erhalten die Aufnahmen call_id und duration. Wir werden vorbeikommen call_id in unser delete_call_recording() um die Aufnahme zu löschen.

for recording in recordings:
  duration = int(recording["duration"])
  call_id = recording["id"]
  if duration <=30:
    response = delete_call_recording(access_token, call_id)

Hier erhalten wir die Aufnahme id von der recordings Liste, dann übergeben Sie diese call_id an die delete_call_recording Funktion. Bei Erfolg ist die Antwort eine leere 204-Antwort.

Löschen von Aufzeichnungen von On-Demand-Anrufen

Das Löschen von Gesprächsaufzeichnungen auf Abruf erfolgt fast genauso wie das Löschen von Gesprächsaufzeichnungen, allerdings verwenden wir die call_recordings API.

Wie zuvor müssen wir alle Aufzeichnungen auf Abruf nach einem bestimmten Datum auflisten. Zunächst müssen wir mit dieser Funktion eine Liste der Aufzeichnungen von Abrufgesprächen abrufen.

on_demand_recordings = []
def on_demand_call_recordings(token, account_id="self", user_id="self", order="start%3ADESC",page=1, page_size=10, start_date=None, end_date=None):
  url = "https://api.vonage.com/t/vbc.prod/call_recording/v1/api/accounts/{}/users/{}/call_recordings?order={}&page={}&page_size={}".format(account_id, user_id, order, page, page_size)
  if start_date:
    url = url + "&start:gte="+start_date

  if end_date:
    url = url + "&start:lte="+end_date

  headers = {
    'Accept': 'application/json',
    'Authorization': 'Bearer {}'.format(token),
  }

  response = requests.request("GET", url, headers=headers).json()
  if "_embedded" in response:
    on_demand_recordings.extend(response["_embedded"]["recordings"])

  if "total_pages" in response:
    if page < response["total_pages"]:
      page = page + 1
      on_demand_call_recordings(token, account_id, user_id, order,page, page_size, start_date, end_date)

  return on_demand_recordings

Hier rufen wir die call_recording API und übergibt den folgenden Parameter:

  • account_id - Die Account-ID für Vonage Business Communications. Sie können verwenden self um auf den Account des authentifizierten Benutzers zu verweisen.
  • user_id - Die Benutzer-ID. Sie können verwenden self um auf den authentifizierten Benutzer zu verweisen.
  • page - Die Anzahl der anzufordernden Seiten.
  • page_size - Die angeforderte Seitengröße.
  • order - Die Reihenfolge der zurückgesendeten Gesprächsaufzeichnungen
  • start:gte - Datensätze nach Startdatum filtern (größer oder gleich)

Als Nächstes erzeugen wir ein Datum, das 30 Tage in der Vergangenheit liegt, und verwenden dieses für die start_date Parameter.

import datetime
import urllib.parse
today = datetime.datetime.now()
last_week = datetime.timedelta(days = 30)
date_diff = today - last_week
encoded_date = urllib.parse.quote_plus(date_diff.strftime('%Y-%m-%dT00:00:00+0000'))

Als Nächstes werden wir eine Funktion schreiben, die die company_call_recordings API zum Löschen der Aufzeichnung durch call_id.

def delete_on_demand_recording(token, call_id, account_id="self", user_id="self"):
  url = "https://api.vonage.com/t/vbc.prod/call_recording/v1/api/accounts/{}/users/{}/call_recordings/{}".format(account_id, call_id)

  headers = {
    'Accept': 'application/json',
    'Authorization': 'Bearer {}'.format(token)
  }

  response = requests.request("DELETE", url, headers=headers)
  return response

Anschließend durchlaufen wir die Aufzeichnungen in einer Schleife und schreiben eine Funktion, um die Aufzeichnung des Anrufs bei Bedarf zu löschen, indem wir die call_id.

access_token = get_token()["access_token"]
recordings = on_demand_call_recordings(access_token, start_date=encoded_date)

for recording in recordings["_embedded"]["recordings"]:
  call_id = recording["id"]
  duration = int(recording["duration"])
  if duration <=30:
    response = delete_on_demand_recording(access_token, call_id)
    print(response)

CRON-Auftrag

Der letzte Schritt besteht darin, die Anrufaufzeichnungen jede Woche mit Hilfe eines CRON-Jobs zu löschen. Auf diese Weise müssen wir diese Funktionen nicht manuell ausführen. Ein CRON-Job ist eine Möglichkeit, Skripte regelmäßig zu bestimmten Zeiten, Daten oder Intervallen auszuführen. Sie können einen CRON-Job lokal erstellen, indem Sie zunächst crontab -e auf einem OSX/Linux-basierten System.

Für einen Windows-Rechner:

  • Melden Sie sich mit einem privilegierten Account an, z. B. Administrator
  • Gehen Sie zu Start > Systemsteuerung > System und Sicherheit > Verwaltung > Taskplaner
  • Klicken Sie im rechten Fenster auf Basisaufgabe erstellen

Unser CRON-Job wird alle 30 Tage ausgeführt. Und so sieht der CRON-Job aus:

* * 30 * * delete_recordings.py >/dev/null 2>&1

Die delete_vbc_recordings_by_duration.py ist ein Skript, das sowohl die Anrufaufzeichnungen als auch die Aufzeichnungen von Anrufen auf Abruf löscht, die weniger als 30 Sekunden lang sind. Werfen Sie einen Blick auf https://crontab-generator.org/ um Ihren eigenen CRON-Job zu erstellen.

Schlussfolgerung

Hier haben wir gezeigt, wie man ein Python-Skript erstellt, das als CRON-Job läuft, um VBC Call Recordings nach ihrer Dauer zu löschen. Das Skript kann an Ihre Bedürfnisse angepasst werden. Wenn Sie viele Anrufe mit einer Dauer von 1 Minute haben, können Sie das Skript nach Bedarf aktualisieren.