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 — a rule fired and references one or more device events
    rule_uuid = data.get('ruleUuid')
    triggered_timestamp_ms = data.get('triggeredTimestampMs')
    rule_triggers = data.get('ruleTriggers', [])
    device_events = data.get('deviceEvents', [])

    trigger_types = ', '.join(t.get('type', '') for t in rule_triggers)
    app.logger.info(f'Rule {rule_uuid} fired at {triggered_timestamp_ms} (triggers: {trigger_types})')

    # Your business logic here — iterate the device events that matched the rule
    for event in device_events:
        activities = ', '.join(event.get('activities', []))
        app.logger.info(
            f"Device {event.get('deviceUuid')} ({event.get('deviceType')}) "
            f"at location {event.get('locationUuid')} reported [{activities}] "
            f"at {event.get('timestampMs')}"
        )

    # 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;
using System.Linq;
using System.Text.Json;

[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] JsonElement payload)
    {
        _logger.LogInformation($"Received webhook: {payload}");

        // Process webhook payload — a rule fired and references one or more device events
        string ruleUuid = payload.GetProperty("ruleUuid").GetString();
        long triggeredTimestampMs = payload.GetProperty("triggeredTimestampMs").GetInt64();

        _logger.LogInformation($"Rule {ruleUuid} fired at {triggeredTimestampMs}");

        // Your business logic here — iterate the device events that matched the rule
        foreach (var evt in payload.GetProperty("deviceEvents").EnumerateArray())
        {
            string deviceUuid = evt.GetProperty("deviceUuid").GetString();
            string deviceType = evt.GetProperty("deviceType").GetString();
            string locationUuid = evt.GetProperty("locationUuid").GetString();
            var activities = evt.GetProperty("activities")
                .EnumerateArray()
                .Select(a => a.GetString());

            _logger.LogInformation(
                $"Device {deviceUuid} ({deviceType}) at location {locationUuid} " +
                $"reported [{string.Join(", ", activities)}]");
        }

        // 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 DeviceEvent struct {
    EventUUID    string   `json:"eventUuid"`
    DeviceUUID   string   `json:"deviceUuid"`
    DeviceType   string   `json:"deviceType"`
    LocationUUID string   `json:"locationUuid"`
    TimestampMs  int64    `json:"timestampMs"`
    Activities   []string `json:"activities"`
}

type RuleTrigger struct {
    Type string `json:"type"`
}

type WebhookPayload struct {
    UUID                 string        `json:"uuid"`
    OrgUUID              string        `json:"orgUuid"`
    RuleUUID             string        `json:"ruleUuid"`
    TriggeredTimestampMs int64         `json:"triggeredTimestampMs"`
    DeviceEvents         []DeviceEvent `json:"deviceEvents"`
    RuleTriggers         []RuleTrigger `json:"ruleTriggers"`
}

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("Rule %s fired at %d", payload.RuleUUID, payload.TriggeredTimestampMs)

    // Iterate the device events that matched the rule
    for _, event := range payload.DeviceEvents {
        log.Printf("Device %s (%s) at location %s reported %v at %d",
            event.DeviceUUID, event.DeviceType, event.LocationUUID,
            event.Activities, event.TimestampMs)
    }

    // 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))
}