Signalbird.Sdk - .NET / ASP.NET Core

dotnet add package Signalbird.Sdk

// Program.cs
builder.Services.AddSignalbird(options =>
{
    options.DomainKey = builder.Configuration["Signalbird:RadioKey"]!;   // sb_secret_live_…
    options.Source = "api-01";
});

builder.Services.AddSignalbirdMessaging(options =>
    options.DomainKey = builder.Configuration["Signalbird:DomainKey"]!);    // sb_…

builder.Services.AddSignalbirdManagement(options =>
    options.DomainKey = builder.Configuration["Signalbird:DomainKey"]!);

var radio = new SignalbirdClient(new SignalbirdOptions { DomainKey = "sb_secret_live_…" });

public class PaymentService(SignalbirdClient signalbird)
{
    public async Task ChargeAsync(Order order, CancellationToken ct)
    {
        try
        {
            await _gateway.ChargeAsync(order, ct);

            await signalbird.InfoAsync("payment", $"Order #{order.Id} succeeded", ct: ct);
        }
        catch (Exception error)
        {
            await signalbird.CriticalAsync("critical", error.Message,
                new Dictionary<string, object?>
                {
                    ["order"] = order.Id,
                    ["gateway"] = "iyzico",
                }, ct);

            throw;   // shipping a log does not swallow the error
        }
    }
}

await signalbird.BatchAsync(new[]
{
    new LogEvent { Channel = "deploy", Message = "v2.4.0 is live", Level = SignalbirdLevel.Info },
    new LogEvent { Channel = "critical", Message = "the queue filled up" },
});

var result = await messaging.SendEmailAsync(new
{
    to = "ahmet@example.com",
    @class = "transactional",     // `class` is a reserved word, escaped with @
    subject = "Your order has shipped",
    body = "<p>Tracking number: 1234</p>",
});

if (!result.Ok)
{
    logger.LogWarning("signalbird: {Code} - {Message}", result.Code, result.Message);
}

await messaging.SendSmsAsync(new { to = "+905551112233", @class = "transactional", body = "Your code: 123456" });
await messaging.PreviewSmsAsync("Hello, your order is ready.");   // spends no quota
await messaging.SendPushAsync(new { to = "contact:42", @class = "transactional", subject = "Order", body = "It has shipped" });

await messaging.ListContactsAsync(new Dictionary<string, object?> { ["q"] = "ahmet" });
await messaging.CreateContactAsync(new { email = "ahmet@example.com", first_name = "Ahmet" });
await messaging.UpdateContactAsync(contactId, new { phone = "+905551112233" });
await messaging.DeleteContactAsync(contactId);

// chunks of 1000, SEQUENTIALLY
await messaging.BulkContactsAsync(rows, new Dictionary<string, object?>
{
    ["list_id"] = 42,
    ["consent_source"] = "web_form",
});

await messaging.CreateCampaignAsync(new
{
    name = "August newsletter",
    channel = "email",
    list_id = 42,
    subject = "What happened this month?",
    body = "<h1>Hello</h1>",
});

// Walks page by page; never pulls the whole list into memory
await foreach (var message in messaging.IterateCampaignMessagesAsync(batchId))
{
    Reconcile(message.GetProperty("external_ref").GetString());
}

// Program.cs - so the raw body can be read
app.Use(async (context, next) =>
{
    context.Request.EnableBuffering();
    await next();
});

// Controller
[HttpPost("/webhooks/signalbird")]
public async Task<IActionResult> Handle()
{
    Request.Body.Position = 0;
    using var reader = new StreamReader(Request.Body);
    var rawBody = await reader.ReadToEndAsync();

    // The RAW body: deserializing the model and re-serializing it breaks the signature
    if (!Webhook.Verify(rawBody, Request.Headers["X-Signalbird-Signature"], _secret))
    {
        return Unauthorized();
    }

    return Ok();
}

// Environment setup (a deploy step or a management command)
var created = await management.CreateModuleKeyAsync("logger", new Dictionary<string, object?> { ["title"] = "Payment errors" });

// `secret` is returned HERE ONLY; the server keeps only its digest
var secret = created.Data?.GetProperty("secret").GetString();
var projectId = created.Data?.GetProperty("project").GetProperty("id").GetInt32();

await management.CreateRadioChannelAsync(projectId!, new
{
    key = "payment",
    name = "Payment",
    level = "critical",
    notify_push = true,
    quiet_from = 0,
    quiet_to = 7,
});

// A chat inbox bot
var inbox = await management.ListConversationsAsync(
    new Dictionary<string, object?> { ["status"] = "open" });

await management.ReplyAsync(conversationId, new { body = "Hello! We will be right with you." });
await management.SetConversationStatusAsync(conversationId, "pending");

public sealed class SbResult
{
    public bool Ok { get; }
    public int Status { get; }
    public JsonElement? Data { get; }
    public string? Code { get; }
    public string? Message { get; }

    public T? Into<T>();     // decodes the body into your type
}

var result = await management.GetAppAsync(id);

var app = result.Into<AppRecord>();

// SignalbirdClient from DI
var hash = signalbird.IdentityHash(user.Id);

identity_hash = hex( HMAC-SHA256( hex(SHA-256(sb_secret_live_…)), external_id ) )

dotnet add package Signalbird.Sdk