Nutrition AI Asynchronous Processing

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"
)

const webhookSignatureKey = "YOUR_WEBHOOK_SECRET_FROM_ADMIN_CONSOLE"

// NutritionRecord represents the webhook payload structure
type NutritionRecord struct {
	ApplicationID int64     `json:"application_id"`
	UID           string    `json:"uid"`
	RecordID      string    `json:"record_id"`
	Status        string    `json:"status"`
	DishName      string    `json:"dish_name"`
	NutriScore    string    `json:"nutri_score"`
	UploadedAt    time.Time `json:"uploaded_at"`
	ModifiedAt    time.Time `json:"modified_at"`
	// Add other fields as needed
}

func main() {
	http.HandleFunc("/nutrition-webhook", func(w http.ResponseWriter, r *http.Request) {
		// Verify HMAC signature
		signature := r.Header.Get("x-body-signature")
		if signature == "" {
			http.Error(w, "Missing signature", http.StatusBadRequest)
			return
		}

		// Read the request body
		body, err := io.ReadAll(r.Body)
		if err != nil {
			http.Error(w, "Failed to read body", http.StatusInternalServerError)
			return
		}

		// Calculate and verify HMAC
		hm := hmac.New(sha256.New, []byte(webhookSignatureKey))
		hm.Write(body)
		expectedSignature := hex.EncodeToString(hm.Sum(nil))
		
		if signature != expectedSignature {
			http.Error(w, "Invalid signature", http.StatusUnauthorized)
			return
		}

		// Parse nutrition record
		var record NutritionRecord
		if err := json.Unmarshal(body, &record); err != nil {
			http.Error(w, "Invalid JSON", http.StatusBadRequest)
			return
		}

		// Process the nutrition record
		fmt.Printf("Received nutrition analysis: %s for user %s\n", record.Status, record.UID)
		if record.Status == "completed" {
			fmt.Printf("Dish: %s, Nutri-Score: %s\n", record.DishName, record.NutriScore)
			// Update your application with the results
		} else if record.Status == "failed" {
			fmt.Printf("Analysis failed for record %s\n", record.RecordID)
			// Handle failure case
		}

		// Respond with success
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("OK"))
	})

	fmt.Println("Starting nutrition webhook server on port 8000")
	http.ListenAndServe(":8000", nil)
}

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

const WEBHOOK_SIGNATURE_KEY = "YOUR_WEBHOOK_SECRET_FROM_ADMIN_CONSOLE";
const app = express();

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

app.post('/nutrition-webhook', (req, res) => {
  const signature = req.headers['x-body-signature'];
  
  if (!signature) {
    return res.status(400).send('Missing signature');
  }

  // Verify HMAC signature
  const hmac = crypto.createHmac('sha256', WEBHOOK_SIGNATURE_KEY);
  hmac.update(req.body);
  const expectedSignature = hmac.digest('hex');
  
  if (signature !== expectedSignature) {
    return res.status(401).send('Invalid signature');
  }

  // Parse nutrition record
  try {
    const nutritionRecord = JSON.parse(req.body);
    
    console.log(`Received nutrition analysis: ${nutritionRecord.status} for user ${nutritionRecord.uid}`);
    
    if (nutritionRecord.status === 'completed') {
      console.log(`Dish: ${nutritionRecord.dish_name}, Nutri-Score: ${nutritionRecord.nutri_score}`);
      
      // Update your application with the results
      updateUserNutritionData(nutritionRecord);
      
    } else if (nutritionRecord.status === 'failed') {
      console.log(`Analysis failed: ${nutritionRecord.failure_reason}`);
      
      // Handle failure case
      handleAnalysisFailure(nutritionRecord.record_id, nutritionRecord.uid);
    }
    
    res.status(200).send('OK');
  } catch (error) {
    res.status(400).send('Invalid JSON');
  }
});

function updateUserNutritionData(nutritionRecord) {
  // Your application logic to store/process the nutrition data
  console.log('Updating user nutrition data...');
}

function handleAnalysisFailure(recordId, uid) {
  // Your application logic to handle failed analysis
  console.log('Handling analysis failure...');
}

app.listen(8000, () => {
  console.log('Nutrition webhook server running on port 8000');
});

import hmac
import hashlib
import json
from datetime import datetime
from flask import Flask, request, Response

app = Flask(__name__)
WEBHOOK_SIGNATURE_KEY = "YOUR_WEBHOOK_SECRET_FROM_ADMIN_CONSOLE"

def verify_signature(body: bytes, signature: str) -> bool:
    """Verify the HMAC signature of the request body."""
    expected_signature = hmac.new(
        WEBHOOK_SIGNATURE_KEY.encode('utf-8'),
        body,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected_signature)

@app.route('/nutrition-webhook', methods=['POST'])
def handle_nutrition_webhook():
    # Get signature from headers
    signature = request.headers.get('x-body-signature')
    if not signature:
        return Response('Missing signature', status=400)
    
    # Get raw request body
    body = request.get_data()
    
    # Verify signature
    if not verify_signature(body, signature):
        return Response('Invalid signature', status=401)
    
    # Parse nutrition record
    try:
        nutrition_record = json.loads(body)
        
        print(f"Received nutrition analysis: {nutrition_record['status']} for user {nutrition_record['uid']}")
        
        if nutrition_record['status'] == 'completed':
            print(f"Dish: {nutrition_record.get('dish_name', 'Unknown')}")
            print(f"Nutri-Score: {nutrition_record.get('nutri_score', 'N/A')}")
            
            # Update your application with the results
            update_user_nutrition_data(nutrition_record)
            
        elif nutrition_record['status'] == 'failed':
            print(f"Analysis failed: {nutrition_record.get('failure_reason', 'Unknown error')}")
            
            # Handle failure case
            handle_analysis_failure(nutrition_record['record_id'], nutrition_record['uid'])
        
        return Response('OK', status=200)
        
    except json.JSONDecodeError:
        return Response('Invalid JSON', status=400)

def update_user_nutrition_data(nutrition_record):
    """Update your application with the nutrition analysis results."""
    print("Updating user nutrition data...")
    # Your application logic here

def handle_analysis_failure(record_id, uid):
    """Handle failed nutrition analysis."""
    print("Handling analysis failure...")
    # Your application logic here

if __name__ == '__main__':
    print('Starting nutrition webhook server on port 8000')
    app.run(host='0.0.0.0', port=8000)

<?php

class NutritionWebhook {
    private const WEBHOOK_SIGNATURE_KEY = 'YOUR_WEBHOOK_SECRET_FROM_ADMIN_CONSOLE';
    
    public function handleRequest() {
        // Verify HMAC signature
        $signature = $_SERVER['HTTP_X_BODY_SIGNATURE'] ?? '';
        if (empty($signature)) {
            http_response_code(400);
            echo 'Missing signature';
            return;
        }

        // Read request body
        $body = file_get_contents('php://input');
        if ($body === false) {
            http_response_code(500);
            echo 'Failed to read body';
            return;
        }

        // Calculate and verify HMAC
        $expectedSignature = hash_hmac('sha256', $body, self::WEBHOOK_SIGNATURE_KEY);
        if ($signature !== $expectedSignature) {
            http_response_code(401);
            echo 'Invalid signature';
            return;
        }

        // Parse nutrition record
        $nutritionRecord = json_decode($body, true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            http_response_code(400);
            echo 'Invalid JSON';
            return;
        }

        // Process the nutrition record
        echo "Received nutrition analysis: {$nutritionRecord['status']} for user {$nutritionRecord['uid']}\n";
        
        if ($nutritionRecord['status'] === 'completed') {
            $dishName = $nutritionRecord['dish_name'] ?? 'Unknown';
            $nutriScore = $nutritionRecord['nutri_score'] ?? 'N/A';
            echo "Dish: {$dishName}, Nutri-Score: {$nutriScore}\n";
            
            // Update your application with the results
            $this->updateUserNutritionData($nutritionRecord);
            
        } elseif ($nutritionRecord['status'] === 'failed') {
            $failureReason = $nutritionRecord['failure_reason'] ?? 'Unknown error';
            echo "Analysis failed: {$failureReason}\n";
            
            // Handle failure case
            $this->handleAnalysisFailure($nutritionRecord['record_id'], $nutritionRecord['uid']);
        }

        http_response_code(200);
        echo 'OK';
    }
    
    private function updateUserNutritionData($nutritionRecord) {
        // Your application logic to store/process the nutrition data
        echo "Updating user nutrition data...\n";
    }
    
    private function handleAnalysisFailure($recordId, $uid) {
        // Your application logic to handle failed analysis
        echo "Handling analysis failure...\n";
    }
}

// Handle the webhook request
$webhook = new NutritionWebhook();
$webhook->handleRequest();
?>