Webhook Listeners

# Install Certbot for Let's Encrypt
sudo apt install certbot python3-certbot-nginx

# Generate SSL certificate
sudo certbot --nginx -d your-domain.com

server {
    listen 443 ssl;
    server_name your-domain.com;

    ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;

    location / {
        proxy_pass http://localhost:80;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

# webhook_server.py
from flask import Flask, request, jsonify
import logging

app = Flask(__name__)
logging.basicConfig(level=logging.INFO)

@app.route('/rhombus-webhook', methods=['POST'])
def webhook():
    data = request.get_json()
    app.logger.info(f'Received webhook: {data}')

    # Process webhook payload
    event_type = data.get('eventType')
    device_id = data.get('deviceId')
    timestamp = data.get('timestamp')

    # Your business logic here
    app.logger.info(f'Event: {event_type} from device {device_id} at {timestamp}')

    # Respond to acknowledge receipt
    return jsonify({'status': 'received'}), 200

@app.route('/health', methods=['GET'])
def health():
    return jsonify({'status': 'healthy'}), 200

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

// WebhookListener.cs
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("/")]
public class WebhookController : ControllerBase
{
    private readonly ILogger<WebhookController> _logger;

    public WebhookController(ILogger<WebhookController> logger)
    {
        _logger = logger;
    }

    [HttpPost("rhombus-webhook")]
    public IActionResult ReceiveWebhook([FromBody] dynamic payload)
    {
        _logger.LogInformation($"Received webhook: {payload}");

        // Process webhook payload
        string eventType = payload.eventType;
        string deviceId = payload.deviceId;
        string timestamp = payload.timestamp;

        // Your business logic here
        _logger.LogInformation($"Event: {eventType} from device {deviceId} at {timestamp}");

        // Respond to acknowledge receipt
        return Ok(new { status = "received" });
    }

    [HttpGet("health")]
    public IActionResult Health()
    {
        return Ok(new { status = "healthy" });
    }
}

// webhook-server.go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)

type WebhookPayload struct {
    EventType string `json:"eventType"`
    DeviceID  string `json:"deviceId"`
    Timestamp string `json:"timestamp"`
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    var payload WebhookPayload
    err := json.NewDecoder(r.Body).Decode(&payload)
    if err != nil {
        http.Error(w, "Bad request", http.StatusBadRequest)
        return
    }

    log.Printf("Received webhook: %+v", payload)
    log.Printf("Event: %s from device %s at %s",
        payload.EventType, payload.DeviceID, payload.Timestamp)

    // Respond to acknowledge receipt
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"status": "received"})
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"status": "healthy"})
}

func main() {
    http.HandleFunc("/rhombus-webhook", webhookHandler)
    http.HandleFunc("/health", healthHandler)

    port := ":8080"
    fmt.Printf("Webhook server running on port %s\n", port)
    log.Fatal(http.ListenAndServe(port, nil))
}