Webhooks

const crypto = require('crypto');

function verifyWebhookSignature(payload, signature, secret) {
  const hmac = crypto.createHmac('sha256', secret);
  const expectedSignature = hmac.update(JSON.stringify(payload)).digest('hex');

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

// Express.js middleware example
app.post('/webhooks/mihu', express.json(), (req, res) => {
  const signature = req.headers['x-mihu-signature'];
  const secret = process.env.MIHU_WEBHOOK_SECRET;

  if (!verifyWebhookSignature(req.body, signature, secret)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  // Process webhook
  const { event, data } = req.body;
  console.log(`Received event: ${event}`);

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

import hmac
import hashlib
import json
from flask import Flask, request, jsonify

app = Flask(__name__)

def verify_webhook_signature(payload, signature, secret):
    expected_signature = hmac.new(
        secret.encode('utf-8'),
        json.dumps(payload).encode('utf-8'),
        hashlib.sha256
    ).hexdigest()

    return hmac.compare_digest(signature, expected_signature)

@app.route('/webhooks/mihu', methods=['POST'])
def handle_mihu_webhook():
    signature = request.headers.get('X-Mindhunters-Signature')
    secret = os.environ.get('MIHU_WEBHOOK_SECRET')
    payload = request.json

    if not verify_webhook_signature(payload, signature, secret):
        return jsonify({'error': 'Invalid signature'}), 401

    # Process webhook
    event_type = payload.get('event')
    data = payload.get('data')
    print(f"Received event: {event_type}")

    return jsonify({'received': True}), 200

<?php
function verifyWebhookSignature($payload, $signature, $secret) {
    $expectedSignature = hash_hmac('sha256', json_encode($payload), $secret);
    return hash_equals($signature, $expectedSignature);
}

// Handle webhook
$payload = json_decode(file_get_contents('php://input'), true);
$signature = $_SERVER['HTTP_X_MIHU_SIGNATURE'] ?? '';
$secret = getenv('MIHU_WEBHOOK_SECRET');

if (!verifyWebhookSignature($payload, $signature, $secret)) {
    http_response_code(401);
    echo json_encode(['error' => 'Invalid signature']);
    exit;
}

// Process webhook
$eventType = $payload['event'];
$data = $payload['data'];

http_response_code(200);
echo json_encode(['received' => true]);
?>

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

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

const WEBHOOK_SECRET = process.env.MIHU_WEBHOOK_SECRET;

// Verify webhook signature
function verifySignature(payload, signature) {
  const hmac = crypto.createHmac('sha256', WEBHOOK_SECRET);
  const expectedSignature = hmac.update(JSON.stringify(payload)).digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

// Webhook handler
app.post('/webhooks/mihu', async (req, res) => {
  try {
    const signature = req.headers['x-mihu-signature'];

    // Verify signature
    if (!verifySignature(req.body, signature)) {
      return res.status(401).json({ error: 'Invalid signature' });
    }

    const { event, data, timestamp } = req.body;

    // Process different event types
    switch (event) {
      case 'conversation.end':
        await handleConversationEnd(data);
        break;

      case 'conversation.update':
        await handleConversationUpdate(data);
        break;

      case 'intent.triggered':
        await handleIntentTriggered(data);
        break;

      default:
        console.log(`Unhandled event type: ${event}`);
    }

    // Acknowledge receipt
    res.status(200).json({ received: true, event });

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

async function handleConversationEnd(data) {
  console.log('Conversation ended:', data.id);
  console.log('Duration:', data.duration, 'seconds');
  console.log('Outcome:', data.summary.outcome);

  // Store in database, send notifications, etc.
}

async function handleConversationUpdate(data) {
  console.log('Conversation update:', data.id);
  console.log('Current status:', data.status);

  // Update real-time dashboard, etc.
}

async function handleIntentTriggered(data) {
  console.log('Intent triggered:', data.intent.name);
  console.log('Confidence:', data.intent.confidence);

  // Trigger actions based on intent
}

app.listen(3000, () => {
  console.log('Webhook server listening on port 3000');
});

from flask import Flask, request, jsonify
import hmac
import hashlib
import json
import os

app = Flask(__name__)

WEBHOOK_SECRET = os.environ.get('MIHU_WEBHOOK_SECRET')

def verify_signature(payload, signature):
    expected_signature = hmac.new(
        WEBHOOK_SECRET.encode('utf-8'),
        json.dumps(payload).encode('utf-8'),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected_signature)

@app.route('/webhooks/mihu', methods=['POST'])
def handle_webhook():
    try:
        signature = request.headers.get('X-Mindhunters-Signature')
        payload = request.json

        # Verify signature
        if not verify_signature(payload, signature):
            return jsonify({'error': 'Invalid signature'}), 401

        event_type = payload.get('event')
        data = payload.get('data')
        timestamp = payload.get('timestamp')

        # Process different event types
        if event_type == 'conversation.end':
            handle_conversation_end(data)
        elif event_type == 'conversation.update':
            handle_conversation_update(data)
        elif event_type == 'intent.triggered':
            handle_intent_triggered(data)
        else:
            print(f"Unhandled event type: {event_type}")

        # Acknowledge receipt
        return jsonify({'received': True, 'event': event_type}), 200

    except Exception as e:
        print(f"Webhook processing error: {e}")
        return jsonify({'error': 'Processing failed'}), 500

def handle_conversation_end(data):
    print(f"Conversation ended: {data['id']}")
    print(f"Duration: {data['duration']} seconds")
    print(f"Outcome: {data['summary']['outcome']}")
    # Store in database, send notifications, etc.

def handle_conversation_update(data):
    print(f"Conversation update: {data['id']}")
    print(f"Current status: {data['status']}")
    # Update real-time dashboard, etc.

def handle_intent_triggered(data):
    print(f"Intent triggered: {data['intent']['name']}")
    print(f"Confidence: {data['intent']['confidence']}")
    # Trigger actions based on intent

if __name__ == '__main__':
    app.run(port=3000)