// Express.js webhook handler
app.post('/webhooks/blackbox-events', async (req, res) => {
  const payload = req.body;

  try {
    switch(payload.type) {
      case 'CompletedWebHookPayload':
        await updateCRMRecord(payload);
        break;
      case 'FailedWebHookPayload':
        await logFailedAttempt(payload);
        break;
      case 'CallDeadLineWebHookPayload':
        await markAsUnreachable(payload);
        break;
    }

    res.status(200).json({ received: true });
  } catch (error) {
    console.error('Webhook processing error:', error);
    res.status(500).json({ error: 'Processing failed' });
  }
});

async function updateCRMRecord(event) {
  const { endpoint, result } = event;
  const { postCallAnalysis, transcript } = result;

  // Find or create contact
  const contact = await crm.findByPhone(endpoint) ||
                  await crm.createContact({ phone: endpoint });

  // Update with call data
  await crm.updateContact(contact.id, {
    lastContactDate: event.completedTime,
    sentiment: postCallAnalysis.sentiment,
    satisfactionScore: postCallAnalysis.satisfactionScore,
    lastTranscript: formatTranscript(transcript),
    tags: extractKeywords(postCallAnalysis)
  });
}

// Webhook processor
async function processCallEvent(event) {
  // Store in time-series database
  await metricsDB.insert({
    timestamp: event.timestamp,
    agentId: event.agentId,
    duration: event.duration,
    outcome: event.result?.postCallAnalysis?.callOutcome,
    sentiment: event.result?.postCallAnalysis?.sentiment
  });

  // Publish to real-time dashboard
  await pubsub.publish('dashboard-updates', {
    type: 'call_completed',
    metrics: calculateRealTimeMetrics(event)
  });
}

function calculateRealTimeMetrics(event) {
  return {
    totalCalls: incrementCounter('total_calls'),
    avgDuration: updateAverage('call_duration', event.duration),
    successRate: calculateSuccessRate(),
    sentimentDistribution: updateSentimentCounts(event)
  };
}

app.post('/webhooks/blackbox', async (req, res) => {
  const payload = req.body;

  if (payload.type === 'CompletedWebHookPayload') {
    const outcome = payload.result.postCallAnalysis?.callOutcome;

    // Trigger workflow based on outcome
    switch(outcome) {
      case 'appointment_booked':
        await workflows.appointmentBooked(payload);
        break;
      case 'needs_callback':
        await workflows.scheduleCallback(payload);
        break;
      case 'not_interested':
        await workflows.updateLeadStatus(payload, 'disqualified');
        break;
      case 'information_provided':
        await workflows.sendFollowUpEmail(payload);
        break;
    }
  }

  res.status(200).json({ received: true });
});

// Workflow definitions
const workflows = {
  async appointmentBooked(event) {
    const info = event.result.postCallAnalysis.extractedInfo;

    // Create calendar event
    await calendar.createEvent({
      title: `Appointment - ${info.customerName}`,
      date: info.appointmentDate,
      time: info.appointmentTime,
      attendees: [info.contactEmail]
    });

    // Send confirmation email
    await email.send({
      to: info.contactEmail,
      template: 'appointment-confirmation',
      data: info
    });

    // Update CRM
    await crm.updateContact({
      email: info.contactEmail,
      nextAppointment: info.appointmentDate,
      status: 'appointment_scheduled'
    });
  },

  async scheduleCallback(event) {
    const preferredTime = event.result.postCallAnalysis.extractedInfo.preferredCallbackTime;

    // Schedule new call
    await blackbox.scheduleCall({
      agentId: event.agentId,
      endpoint: event.endpoint,
      scheduledTime: preferredTime,
      priority: 2 // Higher priority for callbacks
    });

    // Notify sales team
    await slack.sendMessage({
      channel: '#callbacks',
      text: `Callback requested for ${event.endpoint} at ${preferredTime}`
    });
  }
};

async function notifyTeams(payload) {
  const { type, agentId } = payload;

  // Determine notification urgency
  const isUrgent = type === 'FailedWebHookPayload' &&
                   payload.errorMessage?.includes('system');

  // Slack notifications
  if (isUrgent) {
    await slack.sendMessage({
      channel: '#alerts',
      text: `⚠️ System error detected: ${event.errorMessage}`,
      priority: 'high'
    });
  }

  // Email notifications
  if (type === 'CompletedWebHookPayload' &&
      payload.result.postCallAnalysis.sentiment === 'negative') {
    await email.send({
      to: 'support@company.com',
      subject: 'Negative sentiment call alert',
      body: generateCallSummary(payload)
    });
  }

  // SMS notifications for high-value outcomes
  if (payload.result?.postCallAnalysis?.extractedInfo?.dealValue > 10000) {
    await sms.send({
      to: '+14155550123',
      message: `High-value lead captured: ${payload.endpoint}`
    });
  }
}

{
  "url": "https://api.example.com/webhooks/blackbox",
  "headers": {
    "Authorization": "Bearer sk_live_abc123xyz789",
    "X-API-Key": "your-webhook-secret-key"
  }
}

const crypto = require('crypto');

function validateWebhook(req, secret) {
  // Verify signature header
  const signature = req.headers['x-blackbox-signature'];
  if (!signature) {
    throw new Error('Missing signature header');
  }

  // Reconstruct signature
  const payload = JSON.stringify(req.body);
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');

  // Compare signatures
  if (!crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  )) {
    throw new Error('Invalid signature');
  }

  return true;
}

// Use in webhook handler
app.post('/webhooks/blackbox', (req, res) => {
  try {
    validateWebhook(req, process.env.WEBHOOK_SECRET);
    // Process webhook...
  } catch (error) {
    console.error('Webhook validation failed:', error);
    return res.status(401).json({ error: 'Unauthorized' });
  }
});

# Nginx configuration
location /webhooks/blackbox {
    # Allow Dasha BlackBox IP ranges
    allow 52.6.0.0/16;
    allow 54.88.0.0/16;
    deny all;

    proxy_pass http://app_server;
}

function logWebhookEvent(event) {
  // Log metadata only, not sensitive data
  logger.info('Webhook received', {
    eventType: event.eventType,
    callId: event.callId,
    agentId: event.agentId,
    timestamp: event.timestamp,
    // Don't log: transcript, phone numbers, extracted info
  });
}

const agent = await fetch('https://blackbox.dasha.ai/api/v1/agents', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: 'Support Agent',
    resultWebhook: {
      url: 'https://api.example.com/webhooks/call-results',
      headers: {
        'Authorization': 'Bearer webhook-secret-key'
      }
    }
  })
});

POST https://api.example.com/webhooks/blackbox
Content-Type: application/json
User-Agent: Dasha BlackBox-Webhooks/1.0
X-Dasha BlackBox-Event: call.completed
X-Dasha BlackBox-Delivery-ID: delivery_abc123
X-Dasha BlackBox-Signature: sha256=abc123...
Authorization: Bearer your-configured-api-key

{
  "eventType": "call.completed",
  "timestamp": "2025-10-20T15:35:00Z",
  // ... event data
}

HTTP/1.1 200 OK
Content-Type: application/json

{
  "received": true
}

// ✅ Good: Acknowledge immediately, process async
app.post('/webhooks/blackbox', async (req, res) => {
  // Acknowledge receipt immediately
  res.status(200).json({ received: true });

  // Process async (don't block response)
  processWebhookAsync(req.body).catch(err => {
    logger.error('Webhook processing error:', err);
  });
});

async function processWebhookAsync(event) {
  // Long-running tasks here
  await updateCRM(event);
  await sendNotifications(event);
  await generateAnalytics(event);
}

// ❌ Bad: Slow synchronous processing
app.post('/webhooks/blackbox', async (req, res) => {
  // Don't wait for slow operations before responding
  await updateCRM(req.body);  // Might take 3+ seconds
  await sendEmails(req.body); // Might take 2+ seconds

  res.status(200).json({ received: true }); // Too slow!
});

async function processWebhook(event) {
  const { callId, eventType } = event;

  // Check if already processed
  const existing = await db.webhookEvents.findOne({
    callId,
    eventType,
    deliveryId: event.deliveryId
  });

  if (existing) {
    console.log('Duplicate webhook delivery, skipping');
    return;
  }

  // Process event
  await processEvent(event);

  // Record processing
  await db.webhookEvents.insert({
    callId,
    eventType,
    deliveryId: event.deliveryId,
    processedAt: new Date()
  });
}

app.post('/webhooks/blackbox', async (req, res) => {
  try {
    // Validate request
    if (!req.body.eventType) {
      return res.status(400).json({ error: 'Missing eventType' });
    }

    // Acknowledge immediately
    res.status(200).json({ received: true });

    // Process with error handling
    await processWebhookAsync(req.body);

  } catch (error) {
    console.error('Webhook handler error:', error);

    // Still return 200 if already responded
    if (!res.headersSent) {
      res.status(500).json({ error: 'Internal error' });
    }

    // Alert monitoring system
    await monitoring.alert({
      severity: 'error',
      message: 'Webhook processing failed',
      error: error.message
    });
  }
});

const Joi = require('joi');

const webhookSchema = Joi.object({
  eventType: Joi.string().required(),
  timestamp: Joi.string().isoDate().required(),
  callId: Joi.string().required(),
  agentId: Joi.string().required(),
  // ... define full schema
});

function validateWebhookPayload(payload) {
  const { error, value } = webhookSchema.validate(payload);
  if (error) {
    throw new Error(`Invalid webhook payload: ${error.message}`);
  }
  return value;
}

const rateLimit = require('express-rate-limit');

const webhookLimiter = rateLimit({
  windowMs: 1 * 60 * 1000, // 1 minute
  max: 100, // Max 100 webhooks per minute
  message: 'Too many webhook requests'
});

app.post('/webhooks/blackbox', webhookLimiter, handleWebhook);

const metrics = {
  received: 0,
  processed: 0,
  failed: 0,
  avgProcessingTime: 0
};

async function processWebhookAsync(event) {
  const startTime = Date.now();
  metrics.received++;

  try {
    await processEvent(event);
    metrics.processed++;
  } catch (error) {
    metrics.failed++;

    // Alert if failure rate exceeds threshold
    const failureRate = metrics.failed / metrics.received;
    if (failureRate > 0.05) { // Over 5% failure rate
      await alerting.notify({
        type: 'webhook_failure_rate_high',
        rate: failureRate,
        metrics
      });
    }
  } finally {
    const duration = Date.now() - startTime;
    metrics.avgProcessingTime =
      (metrics.avgProcessingTime * (metrics.received - 1) + duration) /
      metrics.received;
  }
}

const response = await fetch(
  'https://blackbox.dasha.ai/api/v1/agents/agent_xyz789',
  {
    method: 'PUT',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      resultWebhook: {
        url: 'https://api.example.com/webhooks/blackbox',
        headers: {
          'Authorization': 'Bearer your-webhook-secret'
        }
      }
    })
  }
);

const updated = await response.json();
console.log('Webhook configured:', updated.resultWebhook);

# Test from external network
curl -X POST https://api.example.com/webhooks/blackbox \
  -H "Content-Type: application/json" \
  -d '{"test": true}'

// Log received headers
app.post('/webhooks/blackbox', (req, res) => {
  console.log('Headers received:', req.headers);
  console.log('Expected auth:', process.env.EXPECTED_AUTH);
  // ... validate
});