Excluir gravações de chamadas da empresa / gravações de chamadas sob demanda por duração

Neste tutorial, você aprenderá como obter uma lista de gravações de chamadas por duração. Isso pode ser útil se você tiver muitas chamadas muito curtas (< 30 segundos) que possam ser excluídas. Isso ajudaria na geração de relatórios, permitindo remover chamadas que tenham pouca ou nenhuma relevância para o relatório. Ou você pode usar isso para remover gravações de chamadas a fim de economizar dinheiro com o armazenamento de arquivos de chamadas.

A API de gravação de chamadas permite que você recupere todas as gravações de chamadas e ofereça filtros por data da chamada, ramal, caller_id, direção (entrante ou saída) e muito mais. Consulte a referência da API para ver todos os filtros disponíveis.

Neste exemplo, faremos uma consulta às gravações do último mês e excluiremos as chamadas com duração inferior a 30 segundos. Usaremos um script em Python para consultar as gravações das chamadas e, para cada gravação, excluiremos a gravação.

Python é a linguagem utilizada para criar o exemplo a seguir; no entanto, você pode usar qualquer linguagem com a qual se sinta mais à vontade. A biblioteca Python a seguir é utilizada em este exemplo.

Pré-requisitos

Antes de começar, você precisará ter um Account de desenvolvedor da Vonage. Se você não tiver um Account de desenvolvedor da Vonage, use este guia para configurar e criar sua conta.

Depois de criar um Account, você precisará seguir estas etapas, utilizando estes guias:

Para este exemplo, você precisará se inscrever no API de gravação de chamadas.

Autenticação

Depois de criar uma aplicação e se inscrever na API de Gravação de Chamadas, você precisará agora fazer login usando suas credenciais do Vonage Business Communications. Esta aplicação de exemplo utiliza a biblioteca Requests para chamar a /api/accounts/ API. Confira o Guia para fazer uma solicitação de API para mais detalhes.

A seguir, vamos criar uma função que solicite o /api/accounts API para gerar um token de acesso.

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()

Para executar essa função, você precisará passar os seguintes parâmetros:

USERNAME - Nome de usuário do Vonage Business Communications. Certifique-se de acrescentar @vbc.prod ao nome de usuário. firstname.lastname@vbc.prod.
PASSWORD - Senha do Vonage Business Communications.
CLIENT_ID - O ID de cliente do seu aplicativo Vonage Developer.
SECRET - A senha para sua inscrição no Programa de Desenvolvedores da Vonage.

Após executar essa função, você deverá ver a seguinte resposta:

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

Obter gravações de chamadas

Antes de chamarmos a API `company_call_recordings`, precisaremos passar uma string de data que corresponda a um mês atrás.

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'))

Aqui, obtemos a data atual usando datetime.datetime.now(), então use datetime.timedelta() função para criar uma data que seja days no passado. Aqui, usamos 30. Em seguida, vamos subtrair a data atual da data de 30 dias atrás, para obter nossa data. Por fim, usamos strftime() para converter o objeto de data em uma string. Definimos a hora como 00:00:00+0000, o que significa que estamos obtendo a data à meia-noite (UTC). Antes de podermos passar a data para a API de Gravações de Chamadas, precisamos codificá-la para URL usando urllib.parse.quote_plus().

A seguir, faremos uma solicitação à API de gravação de chamadas e usaremos o access_token que foi devolvido pelo get_token() função. Isso retornará uma resposta JSON com as gravações das chamadas. Em seguida, passaremos a data encoded_date nesta função

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

Aqui, estamos chamando o company_call_recordings/v1/api/ e passando os seguintes parâmetros:

account_id - O ID da conta da Vonage Business Communications. Você pode usar self para se referir à conta do usuário autenticado.
page - O número de páginas a serem solicitadas.
page_size - O tamanho da página solicitada.
order - A ordem das gravações de chamadas devolvidas
start:gte - Filtrar registros por data de início (maior ou igual a)

Também poderíamos passar start:lte o que retornaria registros anteriores à data especificada.

Assim que obtivermos uma lista de gravações de chamadas, percorreremos cada gravação e obteremos a duração da chamada. Se a duração da chamada for menor ou igual a 30 segundos, a excluiremos. Antes de fazer isso, certifique-se de ter um backup das gravações. Dê uma olhada no Excluir gravações por data Caso de uso para salvar gravações no Amazon S3.

Excluir gravações de chamadas

O get_company_call_recordings() A função retorna uma lista de gravações do Account. A seguir, vamos criar uma função para excluir a gravação pelo seu 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

Essa função obtém a gravação do call_id parâmetro e excluirá a gravação da chamada. Neste exemplo, estamos definindo account_id para self.

A seguir, vamos percorrer as gravações de chamadas do get_company_call_recordings() função que criamos e obter as gravações call_id e duration. Vamos passar em call_id para o nosso delete_call_recording() função para excluir a gravação.

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

Aqui, obtemos a gravação id do recordings lista e, em seguida, passe esse call_id para o delete_call_recording função. Se for bem-sucedida, a resposta será uma resposta 204 vazia.

Excluir gravações de chamadas sob demanda

A exclusão de gravações de chamadas sob demanda será praticamente igual à exclusão de gravações de chamadas; no entanto, vamos usar o call_recordings API.

Assim como antes, precisamos listar todas as gravações sob demanda posteriores a uma determinada data. Primeiro, precisamos obter uma lista das gravações de chamadas sob demanda usando esta função.

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

Aqui, estamos chamando o call_recording API e passando o seguinte parâmetro:

account_id - O ID da conta da Vonage Business Communications. Você pode usar self para se referir à conta do usuário autenticado.
user_id - O ID do usuário. Você pode usar self para se referir ao usuário autenticado.
page - O número de páginas a serem solicitadas.
page_size - O tamanho da página solicitada.
order - A ordem das gravações de chamadas devolvidas
start:gte - Filtrar registros por data de início (maior ou igual a)

A seguir, vamos gerar uma data 30 dias atrás e usá-la para o start_date parâmetro.

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'))

A seguir, vamos escrever uma função que chama a company_call_recordings API para excluir a gravação por 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

Em seguida, percorreremos as gravações e escreveremos uma função para excluir a gravação da chamada sob demanda usando o 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)

Tarefa CRON

A etapa final é excluir as gravações de chamadas semanalmente por meio de uma tarefa CRON. Dessa forma, não precisaremos executar essas funções manualmente. O CRON é uma forma de executar scripts periodicamente em horários, datas ou intervalos fixos. Você pode criar uma tarefa CRON localmente executando primeiro crontab -e em um sistema baseado em OSX/Linux.

Para um computador com Windows:

Faça login com um account com privilégios, por exemplo, Administrador
Vá para Iniciar > Painel de Controle > Sistema e Segurança > Ferramentas Administrativas > Agendador de Tarefas
No painel à direita, clique em “Criar tarefa básica”

Nossa tarefa CRON será executada a cada 30 dias. E eis como será essa tarefa CRON:

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

O delete_vbc_recordings_by_duration.py é um script que excluirá tanto as gravações de chamadas quanto as gravações sob demanda de chamadas com duração inferior a 30 segundos. Dê uma olhada em https://crontab-generator.org/ para criar sua própria tarefa CRON.

Conclusão

Aqui, mostramos como criar um script em Python que é executado como uma tarefa CRON para excluir VBC Call Recordings com base na duração. O script pode ser personalizado para atender às suas necessidades. Se você tiver muitas chamadas com duração de 1 minuto, poderá atualizar o script conforme necessário.