from flask import Flask, request, jsonify
import logging

app = Flask(__name__)

@app.route('/webhook/balance-batch-complete', methods=['POST'])
def handle_balance_webhook():
    try:
        # Parse the webhook payload
        data = request.get_json()
        
        # Validate required fields
        if not all(k in data for k in ['event_uuid', 'type', 'batch_id']):
            return jsonify({'error': 'Missing required fields'}), 400
        
        # Verify the event type
        if data['type'] != 'BALANCE_BATCH_COMPLETED':
            return jsonify({'error': 'Unexpected event type'}), 400
        
        # Log the event
        logging.info(f"Balance batch completed: {data['batch_id']}")
        
        # Process the completed batch (fetch results, update database, etc.)
        process_completed_batch(data['batch_id'])
        
        # Return success response
        return jsonify({'status': 'received'}), 200
        
    except Exception as e:
        logging.error(f"Webhook processing error: {str(e)}")
        return jsonify({'error': 'Internal server error'}), 500

def process_completed_batch(batch_id):
    # Fetch balance results using the batch_id
    # Update your database
    # Trigger any downstream processes
    pass

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

app.use(express.json());

app.post('/webhook/balance-batch-complete', async (req, res) => {
  try {
    const { event_uuid, type, batch_id } = req.body;
    
    // Validate required fields
    if (!event_uuid || !type || !batch_id) {
      return res.status(400).json({ error: 'Missing required fields' });
    }
    
    // Verify the event type
    if (type !== 'BALANCE_BATCH_COMPLETED') {
      return res.status(400).json({ error: 'Unexpected event type' });
    }
    
    // Log the event
    console.log(`Balance batch completed: ${batch_id}`);
    
    // Process the completed batch
    await processCompletedBatch(batch_id);
    
    // Return success response
    res.status(200).json({ status: 'received' });
    
  } catch (error) {
    console.error('Webhook processing error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

async function processCompletedBatch(batchId) {
  // Fetch balance results using the batchId
  // Update your database
  // Trigger any downstream processes
}

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

<?php
header('Content-Type: application/json');

// Get the webhook payload
$payload = file_get_contents('php://input');
$data = json_decode($payload, true);

// Validate JSON parsing
if (json_last_error() !== JSON_ERROR_NONE) {
    http_response_code(400);
    echo json_encode(['error' => 'Invalid JSON payload']);
    exit;
}

// Validate required fields
if (!isset($data['event_uuid']) || !isset($data['type']) || !isset($data['batch_id'])) {
    http_response_code(400);
    echo json_encode(['error' => 'Missing required fields']);
    exit;
}

// Verify the event type
if ($data['type'] !== 'BALANCE_BATCH_COMPLETED') {
    http_response_code(400);
    echo json_encode(['error' => 'Unexpected event type']);
    exit;
}

// Log the event
error_log("Balance batch completed: " . $data['batch_id']);

try {
    // Process the completed batch
    processCompletedBatch($data['batch_id']);
    
    // Return success response
    http_response_code(200);
    echo json_encode(['status' => 'received']);
    
} catch (Exception $e) {
    error_log("Webhook processing error: " . $e->getMessage());
    http_response_code(500);
    echo json_encode(['error' => 'Internal server error']);
}

function processCompletedBatch($batchId) {
    // Fetch balance results using the batchId
    // Update your database
    // Trigger any downstream processes
}
?>

import time
import requests

def wait_for_batch_completion(batch_id, api_key, max_wait=3600):
    """
    Poll for batch completion with exponential backoff
    """
    start_time = time.time()
    poll_interval = 30  # Start with 30 seconds
    
    while time.time() - start_time < max_wait:
        # Check if batch is complete
        response = requests.get(
            f"https://api.rightfoot.com/v1/balances?batchId={batch_id}&limit=1",
            headers={"Authorization": f"Bearer {api_key}"}
        )
        
        if response.status_code == 200:
            # Batch is complete
            return True
        elif response.status_code == 404:
            # Batch still processing
            time.sleep(poll_interval)
            poll_interval = min(poll_interval * 1.5, 300)  # Cap at 5 minutes
        else:
            # Handle error
            raise Exception(f"Error checking batch status: {response.status_code}")
    
    return False  # Timeout reached

async function waitForBatchCompletion(batchId, apiKey, maxWait = 3600) {
  const startTime = Date.now();
  let pollInterval = 30000; // Start with 30 seconds
  
  while ((Date.now() - startTime) / 1000 < maxWait) {
    try {
      const response = await fetch(
        `https://api.rightfoot.com/v1/balances?batchId=${batchId}&limit=1`,
        {
          headers: {
            'Authorization': `Bearer ${apiKey}`
          }
        }
      );
      
      if (response.status === 200) {
        // Batch is complete
        return true;
      } else if (response.status === 404) {
        // Batch still processing
        await new Promise(resolve => setTimeout(resolve, pollInterval));
        pollInterval = Math.min(pollInterval * 1.5, 300000); // Cap at 5 minutes
      } else {
        // Handle error
        throw new Error(`Error checking batch status: ${response.status}`);
      }
    } catch (error) {
      throw error;
    }
  }
  
  return false; // Timeout reached
}