Webhook Configuration

Dashboard Configuration

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

// Middleware to parse JSON
app.use(express.json());

// Webhook verification
const verifyWebhook = (req, res, next) => {
  const signature = req.headers['x-hub-signature-256'];
  const payload = JSON.stringify(req.body);
  const expectedSignature = crypto
    .createHmac('sha256', process.env.WEBHOOK_SECRET)
    .update(payload)
    .digest('hex');
  
  if (signature !== `sha256=${expectedSignature}`) {
    return res.status(401).send('Unauthorized');
  }
  
  next();
};

// Webhook endpoint
app.post('/webhook', verifyWebhook, (req, res) => {
  const body = req.body;
  
  // Check if it's a webhook verification request
  if (body.object === 'whatsapp_business_account') {
    body.entry.forEach(entry => {
      entry.changes.forEach(change => {
        if (change.field === 'messages') {
          const value = change.value;
          
          // Handle incoming messages
          if (value.messages) {
            value.messages.forEach(message => {
              console.log('Received message:', message);
              handleIncomingMessage(message);
            });
          }
          
          // Handle message status updates
          if (value.statuses) {
            value.statuses.forEach(status => {
              console.log('Message status:', status);
              handleMessageStatus(status);
            });
          }
          
          // Handle message errors
          if (value.errors) {
            value.errors.forEach(error => {
              console.log('Message error:', error);
              handleMessageError(error);
            });
          }
        }
      });
    });
  }
  
  res.status(200).send('OK');
});

// Handle incoming messages
function handleIncomingMessage(message) {
  const from = message.from;
  const messageId = message.id;
  const messageType = message.type;
  
  if (messageType === 'text') {
    const text = message.text.body;
    console.log(`Text message from ${from}: ${text}`);
    
    // Process the message and send response
    processTextMessage(from, text);
  } else if (messageType === 'image') {
    const image = message.image;
    console.log(`Image message from ${from}: ${image.id}`);
    
    // Handle image message
    processImageMessage(from, image);
  }
}

// Handle message status updates
function handleMessageStatus(status) {
  const messageId = status.id;
  const statusType = status.status;
  const timestamp = status.timestamp;
  
  console.log(`Message ${messageId} status: ${statusType} at ${timestamp}`);
  
  // Update your database with the status
  updateMessageStatus(messageId, statusType, timestamp);
}

// Handle message errors
function handleMessageError(error) {
  const code = error.code;
  const title = error.title;
  const message = error.message;
  
  console.error(`Message error ${code}: ${title} - ${message}`);
  
  // Handle the error appropriately
  handleError(code, title, message);
}

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Webhook server running on port ${PORT}`);
});

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

app = Flask(__name__)

def verify_webhook_signature(payload, signature):
    """Verify webhook signature"""
    expected_signature = hmac.new(
        os.getenv('WEBHOOK_SECRET').encode('utf-8'),
        payload,
        hashlib.sha256
    ).hexdigest()
    
    return hmac.compare_digest(f'sha256={expected_signature}', signature)

@app.route('/webhook', methods=['POST'])
def webhook():
    # Get the signature from headers
    signature = request.headers.get('X-Hub-Signature-256')
    
    # Verify the signature
    if not verify_webhook_signature(request.get_data(), signature):
        return jsonify({'error': 'Unauthorized'}), 401
    
    # Parse the webhook payload
    body = request.get_json()
    
    # Process the webhook
    if body.get('object') == 'whatsapp_business_account':
        for entry in body.get('entry', []):
            for change in entry.get('changes', []):
                if change.get('field') == 'messages':
                    value = change.get('value', {})
                    
                    # Handle incoming messages
                    for message in value.get('messages', []):
                        handle_incoming_message(message)
                    
                    # Handle message status updates
                    for status in value.get('statuses', []):
                        handle_message_status(status)
                    
                    # Handle message errors
                    for error in value.get('errors', []):
                        handle_message_error(error)
    
    return jsonify({'status': 'success'}), 200

def handle_incoming_message(message):
    """Handle incoming messages"""
    from_number = message.get('from')
    message_id = message.get('id')
    message_type = message.get('type')
    
    if message_type == 'text':
        text = message.get('text', {}).get('body', '')
        print(f"Text message from {from_number}: {text}")
        
        # Process text message
        process_text_message(from_number, text)
    
    elif message_type == 'image':
        image = message.get('image', {})
        print(f"Image message from {from_number}: {image.get('id')}")
        
        # Process image message
        process_image_message(from_number, image)

def handle_message_status(status):
    """Handle message status updates"""
    message_id = status.get('id')
    status_type = status.get('status')
    timestamp = status.get('timestamp')
    
    print(f"Message {message_id} status: {status_type} at {timestamp}")
    
    # Update database with status
    update_message_status(message_id, status_type, timestamp)

def handle_message_error(error):
    """Handle message errors"""
    code = error.get('code')
    title = error.get('title')
    message = error.get('message')
    
    print(f"Message error {code}: {title} - {message}")
    
    # Handle the error
    handle_error(code, title, message)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=3000, debug=True)