Subscribing To Events

var sysInfo = await client.GetSysInfo();
var mqttEndpoint = sysInfo.EventPublisherUrl; // e.g., "wss://events.us.acresecurity.cloud"
var mqttUrl = $"{mqttEndpoint}/mqtt";

# Using cURL and jq
MQTT_ENDPOINT=$(curl -s https://api.us.acresecurity.cloud/api/sysinfo | jq -r '.EventPublisherUrl')
echo "MQTT Endpoint: ${MQTT_ENDPOINT}/mqtt"

/{folder}/{object}/{eventType}/{band}

# Once-per-event firehose for an instance, any event type, any band
/69705d500000000000000000/$/+/+

# All events of one event type (e.g., access granted "61cb71500000000000000000"),
# once per event, at any priority band
/69705d500000000000000000/$/61cb71500000000000000000/+

# All events at priority band 200 across every event type, once per event
/69705d500000000000000000/$/+/200

# Targeted: events on a specific reader, for one event type, at any band
/69705d500000000000000000/65aca4d00000000000000000/61cb71500000000000000000/+

# Sub-band events of one event type (priority below the lowest configured band)
/69705d500000000000000000/$/61cb71500000000000000000

# Legacy folder firehose — every event in the instance, once per event
/69705d500000000000000000/$

# Legacy per-object — events involving a specific person
/69705d500000000000000000/678f29d00000000000000000

# Server clock (no authentication required)
serverclock

/{folder}/$/+/100
/{folder}/$/+/200
/{folder}/$/+/255

/5fa8…aa/$/eee5…ff/100              ← once-per-event banded firehose (canonical)
/5fa8…aa/bbb1…cc/eee5…ff/100        ← targeted to the reader
/5fa8…aa/ccc2…dd/eee5…ff/100        ← targeted to the person
/5fa8…aa/aaa0…bb/eee5…ff/100        ← targeted to the publishing app
/5fa8…aa/$                          ← legacy folder firehose
/5fa8…aa/bbb1…cc                    ← legacy per-object (reader)

dotnet add package MQTTnet
dotnet add package MQTTnet.Extensions.ManagedClient
dotnet add package MongoDB.Bson
dotnet add package Feenics.Keep.WebApi.Model.Standard
dotnet add package Feenics.Keep.WebApi.Wrapper.Standard

using System;
using System.Threading.Tasks;
using Feenics.Keep.WebApi.Wrapper;
using Feenics.Keep.WebApi.Model;
using MQTTnet;
using MQTTnet.Client;
using MQTTnet.Extensions.ManagedClient;
using MongoDB.Bson.Serialization;

class EventSubscriber
{
    static async Task Main(string[] args)
    {
        // Configuration
        const string baseUrl = "https://api.us.acresecurity.cloud";
        const string instance = "QuickStart";
        const string username = "admin";
        const string password = "your-password";
        
        // 1. Login to API
        var client = new Client(baseUrl, userAgent: "EventMonitor/1.0");
        var (isLoggedIn, _, _) = await client.LoginAsync(instance, username, password);
        
        if (!isLoggedIn)
        {
            Console.WriteLine("❌ Login failed");
            return;
        }
        
        var currentInstance = await client.GetCurrentInstanceAsync();
        Console.WriteLine($"✓ Logged in to instance: {currentInstance.CommonName}");
        
        // 2. Get MQTT endpoint dynamically
        var sysInfo = await client.GetSysInfo();
        var mqttEndpoint = $"{sysInfo.EventPublisherUrl}/mqtt";
        Console.WriteLine($"✓ MQTT Endpoint: {mqttEndpoint}");
        
        // 3. Configure MQTT client
        var options = new ManagedMqttClientOptionsBuilder()
            .WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
            .WithClientOptions(new MqttClientOptionsBuilder()
                .WithCommunicationTimeout(TimeSpan.FromSeconds(5))
                .WithKeepAlivePeriod(TimeSpan.FromSeconds(7.5))
                .WithCredentials(client.TokenResponse.access_token, "")
                .WithWebSocketServer(mqttEndpoint)
                .Build())
            .Build();
        
        // 4. Create and configure event handlers
        var eventsClient = new MqttFactory().CreateManagedMqttClient();
        
        eventsClient.UseConnectedHandler(async e =>
        {
            Console.WriteLine("✓ MQTT Connected");
            
            // Subscribe to all events in this instance
            await eventsClient.SubscribeAsync(new TopicFilterBuilder()
                .WithTopic($"/{currentInstance.Key}/$")
                .Build());
            
            Console.WriteLine($"✓ Subscribed to: /{currentInstance.Key}/$");
        });
        
        eventsClient.UseDisconnectedHandler(e =>
        {
            Console.WriteLine($"⚠️  MQTT Disconnected. Was connected: {e.ClientWasConnected}");
            if (e.Exception != null)
            {
                Console.WriteLine($"   Reason: {e.Exception.Message}");
            }
        });
        
        eventsClient.UseApplicationMessageReceivedHandler(async e =>
        {
            try
            {
                // Deserialize the event message
                var message = BsonSerializer.Deserialize<EventMessageData>(e.ApplicationMessage.Payload);
                
                // Display event details
                Console.WriteLine($"\n📨 Event Received:");
                Console.WriteLine($"   Key:        {message.Key}");
                Console.WriteLine($"   Type:       {message.EventTypeKey}");
                Console.WriteLine($"   Time:       {message.OccurredOn:yyyy-MM-dd HH:mm:ss} UTC");
                Console.WriteLine($"   Priority:   {message.Priority}");
                Console.WriteLine($"   Message:    {message.MessageLong}");
                
                // Optional: Deserialize event-specific data
                if (!string.IsNullOrEmpty(message.EventDataBsonBase64))
                {
                    var eventData = Convert.FromBase64String(message.EventDataBsonBase64);
                    // Process event-specific data based on EventTypeKey
                }
                
                // Display object links (what objects are involved)
                if (message.ObjectLinks?.Length > 0)
                {
                    Console.WriteLine($"   Objects:");
                    foreach (var link in message.ObjectLinks)
                    {
                        Console.WriteLine($"     - {link.Moniker}: {link.CommonName} ({link.Key})");
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"❌ Error processing message: {ex.Message}");
            }
        });
        
        // 5. Start MQTT client
        await eventsClient.StartAsync(options);
        Console.WriteLine("✓ MQTT Client Started");
        
        // 6. Keep running (press Ctrl+C to exit)
        Console.WriteLine("\nListening for events... (Press Ctrl+C to exit)\n");
        await Task.Delay(Timeout.Infinite);
    }
}

✓ Logged in to instance: QuickStart Demo
✓ MQTT Endpoint: wss://events.us.acresecurity.cloud/mqtt
✓ MQTT Connected
✓ Subscribed to: /69705d500000000000000000/$
✓ MQTT Client Started

Listening for events... (Press Ctrl+C to exit)

📨 Event Received:
   Key:        637801234567890123
   Type:       63cb71500000000000000000
   Time:       2026-01-21 18:46:58 UTC
   Priority:   200
   Message:    Access Granted: John Smith at Front Door
   Objects:
     - Person: John Smith (678f29d00000000000000000)
     - Reader: Front Door Reader (65aca4d00000000000000000)

using MQTTnet;
using MQTTnet.Client;
using MongoDB.Bson.Serialization;

class ServerClockMonitor
{
    static async Task Main(string[] args)
    {
        const string mqttEndpoint = "wss://events.us.acresecurity.cloud/mqtt";
        
        var mqttClient = new MqttFactory().CreateMqttClient();
        
        var options = new MqttClientOptionsBuilder()
            .WithWebSocketServer(mqttEndpoint)
            .Build();
        
        mqttClient.ApplicationMessageReceivedAsync += async e =>
        {
            var clockData = BsonSerializer.Deserialize<ServerClockMessage>(e.ApplicationMessage.Payload);
            Console.WriteLine($"Server Time: {clockData.CurrentTime:HH:mm:ss} UTC");
        };
        
        await mqttClient.ConnectAsync(options);
        
        // Subscribe to the public serverclock topic (no authentication required)
        await mqttClient.SubscribeAsync("serverclock");
        Console.WriteLine("Subscribed to serverclock - receiving heartbeats...\n");
        
        await Task.Delay(Timeout.Infinite);
    }
}

// Define the server clock message structure
public class ServerClockMessage
{
    public DateTime CurrentTime { get; set; }
}

# Get MQTT endpoint from SysInfo
ACCESS_TOKEN="your-access-token"
BASE_URL="https://api.us.acresecurity.cloud"

curl -s "${BASE_URL}/api/sysinfo" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" | jq '.EventPublisherUrl'
# Output: "wss://events.us.acresecurity.cloud"

# Using mosquitto_sub (install via: brew install mosquitto)
mosquitto_sub -h events.us.acresecurity.cloud \
  -p 443 \
  -t "/YOUR_INSTANCE_KEY/$" \
  -u "$ACCESS_TOKEN" \
  -P "" \
  --capath /etc/ssl/certs \
  -d