How to work with call data

const createWebhook = async (accessToken) => {
  try {
    const response = await fetch('https://api.aircall.io/v1/webhooks', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        custom_name: 'YOUR_APP_NAME',
        url: 'https://your-app.example.com/aircall/webhook',
        events: [
          'call.created', 'call.ringing_on_agent', 'call.agent_declined',
          'call.answered', 'call.transferred', 'call.hungup',
          'call.ended', 'call.voicemail_left', 'call.assigned',
          'call.archived', 'call.tagged', 'call.commented'
        ]
      })
    });

    const data = await response.json();

    if (!response.ok) {
      throw new Error(data.message || 'Failed to create webhook');
    }

    // Store data.webhook.token against your user record.
    // You'll need it to verify incoming webhook signatures.
    return data.webhook.token;
  } catch (err) {
    console.error('Failed to create webhook:', err.message);
    throw err;
  }
};

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

app.post('/aircall/webhook', (req, res) => {
  // Always respond 200 immediately.
  res.sendStatus(200);

  const { event, data } = req.body;

  // Process asynchronously to avoid timeouts.
  processCallEvent(event, data).catch(console.error);
});

const processCallEvent = async (event, callData) => {
  switch (event) {
    case 'call.ended':
      // Full call data is available — sync to CRM, trigger AI enrichment, etc.
      await upsertCallRecord(callData);
      break;

    case 'call.tagged':
    case 'call.commented':
      // Update tags or notes on an existing call record.
      await updateCallRecord(callData.id, callData);
      break;

    default:
      // Store all other events for audit purposes.
      await logEvent(event, callData);
  }
};

const upsertCallRecord = async (callData) => {
  // TODO: insert or update a call record using callData.id as the primary key.
  // Include tags and comments — agents submit these during or after the call.
};

const updateCallRecord = async (callId, callData) => { ... }
const logEvent = async (event, callData) => { ... }

app.listen(3000);

/**
 * Fetches all calls, iterating through every page.
 * Adds a 1 second delay between requests to respect rate limits.
 *
 * @param {string} accessToken
 * @param {Object} [params]     - Optional query params (e.g. { from, to, order })
 * @returns {Promise<Array>}
 */
const fetchAllCalls = async (accessToken, params = {}) => {
  const headers = {
    'Authorization': `Bearer ${accessToken}`,
    'Content-Type': 'application/json'
  };

  let url = new URL('https://api.aircall.io/v1/calls');
  url.search = new URLSearchParams({ per_page: 50, order: 'desc', ...params });

  const calls = [];

  while (url) {
    const response = await fetch(url, { headers });
    const data = await response.json();

    if (!response.ok) {
      throw new Error(data.message || 'Failed to fetch calls');
    }

    calls.push(...data.calls);
    url = data.meta?.next_page_link ? new URL(data.meta.next_page_link) : null;

    if (url) await delay(1000); // avoid hitting the 60 req/min rate limit
  }

  return calls;
};

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// Fetch all calls from the past 7 days
const now = Math.floor(Date.now() / 1000);
const sevenDaysAgo = now - (7 * 24 * 60 * 60);

const calls = await fetchAllCalls(accessToken, {
  from: sevenDaysAgo,
  to: now
});

const isMissed = (call) =>
  call.status === 'done' && call.missed_call_reason != null;

// Common values of missed_call_reason:
// 'out_of_opening_hours', 'short_abandoned', 'abandoned_in_ivr', 'no_available_agent'

// Total duration (ring time + talk time + hold time)
const totalDuration = call.ended_at - call.started_at; // seconds

// In-call (talk) duration only — null for unanswered calls
const talkDuration = call.answered_at
  ? call.ended_at - call.answered_at
  : null;

const fs = require('fs');
const { Readable } = require('stream');
const { pipeline } = require('stream/promises');

/**
 * Downloads a call recording and saves it to the local filesystem.
 * Call this immediately on receiving a call.ended event.
 */
const downloadRecording = async (call) => {
  if (!call.recording) return null;

  const response = await fetch(call.recording);

  if (!response.ok) {
    throw new Error(`Failed to download recording: ${response.status}`);
  }

  const dest = `./recordings/${call.id}.mp3`;
  const writer = fs.createWriteStream(dest);

  await pipeline(Readable.fromWeb(response.body), writer);

  return dest;
};