{
  "event": "interview.created",
  "timestamp": "2024-03-15T10:30:00Z",
  "data": {
    "interview": {
      "id": "int_1234567890",
      "title": "Senior Frontend Developer",
      "type": "technical",
      "duration": 60,
      "created_at": "2024-03-15T10:30:00Z",
      "created_by": "user_123"
    }
  }
}

{
  "event": "session.started",
  "timestamp": "2024-03-15T14:00:00Z",
  "data": {
    "session": {
      "id": "sess_9876543210",
      "interview_id": "int_1234567890",
      "candidate": {
        "id": "cand_555666777",
        "email": "candidate@example.com",
        "name": "John Doe"
      },
      "started_at": "2024-03-15T14:00:00Z",
      "ip_address": "192.168.1.100",
      "user_agent": "Mozilla/5.0..."
    }
  }
}

{
  "event": "session.completed",
  "timestamp": "2024-03-15T15:00:00Z",
  "data": {
    "session": {
      "id": "sess_9876543210",
      "interview_id": "int_1234567890",
      "candidate": {
        "id": "cand_555666777",
        "email": "candidate@example.com",
        "name": "John Doe"
      },
      "completed_at": "2024-03-15T15:00:00Z",
      "duration_minutes": 58,
      "overall_score": 85,
      "status": "completed"
    }
  }
}

const express = require('express');
const crypto = require('crypto');
const app = express();

// Middleware to capture raw body for signature verification
app.use('/webhooks', express.raw({ type: 'application/json' }));

app.post('/webhooks/ntrvsta', (req, res) => {
  const signature = req.headers['x-ntrvsta-signature'];
  const payload = req.body;
  
  // Verify webhook signature
  if (!verifySignature(payload, signature)) {
    return res.status(401).send('Invalid signature');
  }
  
  const event = JSON.parse(payload);
  
  // Process the event
  handleWebhookEvent(event);
  
  res.status(200).send('OK');
});

function verifySignature(payload, signature) {
  const secret = process.env.NTRVSTA_WEBHOOK_SECRET;
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
    
  return crypto.timingSafeEqual(
    Buffer.from(signature, 'hex'),
    Buffer.from(expectedSignature, 'hex')
  );
}

function handleWebhookEvent(event) {
  switch (event.event) {
    case 'session.completed':
      handleSessionCompleted(event.data.session);
      break;
    case 'session.started':
      handleSessionStarted(event.data.session);
      break;
    default:
      console.log(`Unhandled event: ${event.event}`);
  }
}

const webhook = await client.webhooks.create({
  url: 'https://your-app.com/webhooks/ntrvsta',
  events: [
    'session.completed',
    'session.started',
    'candidate.invited'
  ],
  secret: 'your_webhook_secret_here',
  active: true
});

console.log('Webhook created:', webhook.id);

async function handleSessionCompleted(session) {
  try {
    // Update your database
    await updateCandidateStatus(session.candidate.id, 'completed');
    
    // Send notification to hiring manager
    await sendNotification({
      type: 'interview_completed',
      candidate: session.candidate.name,
      score: session.overall_score,
      interview_id: session.interview_id
    });
    
    // Trigger next steps in hiring pipeline
    await triggerNextSteps(session);
    
  } catch (error) {
    console.error('Error processing session completion:', error);
    // Implement retry logic or error handling
  }
}

async function handleCandidateInvited(candidate) {
  try {
    // Log invitation in your system
    await logCandidateInvitation(candidate);
    
    // Update ATS status
    await updateATSStatus(candidate.id, 'interview_invited');
    
    // Schedule follow-up reminders
    await scheduleReminders(candidate);
    
  } catch (error) {
    console.error('Error processing candidate invitation:', error);
  }
}

const MAX_RETRIES = 3;
const RETRY_DELAY = 1000; // 1 second

async function processWebhookWithRetry(event, retryCount = 0) {
  try {
    await processWebhookEvent(event);
  } catch (error) {
    if (retryCount < MAX_RETRIES) {
      console.log(`Retrying webhook processing (attempt ${retryCount + 1})`);
      await new Promise(resolve => setTimeout(resolve, RETRY_DELAY * Math.pow(2, retryCount)));
      return processWebhookWithRetry(event, retryCount + 1);
    } else {
      console.error('Max retries exceeded for webhook event:', event.id);
      // Log to error tracking system
      await logWebhookError(event, error);
    }
  }
}

function verifyWebhookSignature(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload, 'utf8')
    .digest('hex');
    
  // Use timing-safe comparison to prevent timing attacks
  return crypto.timingSafeEqual(
    Buffer.from(signature, 'hex'),
    Buffer.from(expectedSignature, 'hex')
  );
}

// Usage in webhook handler
app.post('/webhooks/ntrvsta', (req, res) => {
  const signature = req.headers['x-ntrvsta-signature'];
  const payload = req.body;
  const secret = process.env.NTRVSTA_WEBHOOK_SECRET;
  
  if (!verifyWebhookSignature(payload, signature, secret)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
  
  // Process webhook...
});

# Install ngrok
npm install -g ngrok

# Start your local server
node server.js

# In another terminal, expose your local server
ngrok http 3000

# Use the ngrok URL for webhook registration
# https://abc123.ngrok.io/webhooks/ntrvsta

# Test your webhook endpoint
curl -X POST https://your-app.com/webhooks/ntrvsta \
  -H "Content-Type: application/json" \
  -H "X-NTRVSTA-Signature: your_test_signature" \
  -d '{
    "event": "session.completed",
    "timestamp": "2024-03-15T15:00:00Z",
    "data": {
      "session": {
        "id": "test_session_123",
        "overall_score": 85
      }
    }
  }'

// Trigger test webhook events
await client.webhooks.test({
  webhookId: 'webhook_123',
  event: 'session.completed',
  testData: {
    session: {
      id: 'test_session_456',
      overall_score: 92
    }
  }
});

// Enable webhook debugging
const webhook = await client.webhooks.update('webhook_123', {
  debug: true,
  logLevel: 'detailed'
});

// View webhook delivery logs
const logs = await client.webhooks.getLogs('webhook_123', {
  limit: 50,
  status: 'failed' // or 'success', 'pending'
});

// Get webhook delivery statistics
const stats = await client.webhooks.getStats('webhook_123', {
  timeRange: '24h'
});

console.log('Delivery stats:', {
  total: stats.total_deliveries,
  successful: stats.successful_deliveries,
  failed: stats.failed_deliveries,
  success_rate: stats.success_rate
});

// Get failed deliveries for investigation
const failedDeliveries = await client.webhooks.getFailedDeliveries('webhook_123', {
  limit: 20,
  since: '2024-03-15T00:00:00Z'
});

failedDeliveries.forEach(delivery => {
  console.log(`Failed delivery: ${delivery.id}`);
  console.log(`Error: ${delivery.error_message}`);
  console.log(`Retry count: ${delivery.retry_count}`);
});

// Test webhook connectivity
const testResult = await client.webhooks.testConnectivity('webhook_123');
if (!testResult.success) {
  console.log('Connection test failed:', testResult.error);
}

// Debug signature verification
function debugSignatureVerification(payload, receivedSignature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload, 'utf8')
    .digest('hex');
    
  console.log('Expected signature:', expectedSignature);
  console.log('Received signature:', receivedSignature);
  console.log('Payload length:', payload.length);
  console.log('Secret length:', secret.length);
}

async function syncWithATS(session) {
  const atsClient = new ATSClient();
  
  await atsClient.updateCandidate(session.candidate.id, {
    interview_status: 'completed',
    interview_score: session.overall_score,
    interview_date: session.completed_at,
    next_step: session.overall_score >= 80 ? 'technical_round_2' : 'rejected'
  });
}

async function sendSlackNotification(session) {
  const slackClient = new SlackClient();
  
  const message = {
    channel: '#hiring',
    text: `Interview completed for ${session.candidate.name}`,
    attachments: [{
      color: session.overall_score >= 80 ? 'good' : 'warning',
      fields: [
        { title: 'Score', value: `${session.overall_score}/100`, short: true },
        { title: 'Duration', value: `${session.duration_minutes} minutes`, short: true }
      ]
    }]
  };
  
  await slackClient.sendMessage(message);
}