Relay/RelayServer/Program.cs

using System.Text.Json;
using RelayServer.Services;
using WebSocketSharp.Server;
using Microsoft.AspNetCore.SignalR;
using Microsoft.AspNetCore.Builder;
using RelayServer.Models;

var surrealService = new SurrealService();
var coreClient = new CoreClientService();
var cryptoService = new ChannelCryptoService();
//TODO: Move everything into a MAIN function
await using var db = await surrealService.ConnectAsync();

ChatTest.ClientKeyService = new ClientKeyService(db);
ChatTest.Db = db;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSignalR();

var app = builder.Build();
app.MapGet("/", () => "Server Running!");
app.MapHub<WebRtcHub>("/webrtc");

var wssv = new WebSocketServer("ws://localhost:1337");
wssv.AddWebSocketService<ChatTest>("/");
wssv.Start();
Console.WriteLine("WebSocket server started");

var keeper = await coreClient.GetUserByUsernameAsync("Keeper317");
var kira = await coreClient.GetUserByUsernameAsync("Ru_Kira");
var test = await coreClient.GetUserByUsernameAsync("Test");

if (keeper is null || kira is null || test is null)
{
    Console.WriteLine("One or more required users do not exist in RelayCore.");
    return;
}

if (!keeper.Licensed || !kira.Licensed || !test.Licensed)
{
    Console.WriteLine("One or more required users are not licensed.");
    return;
}

Console.WriteLine($"Core verified user: {keeper.Username}");
Console.WriteLine($"Core verified user: {kira.Username}");
Console.WriteLine($"Core verified user: {test.Username}");

var server = await db.Create("servers", new Servers
{
    Name = "Test Server",
    OwnerUserId = keeper.Id,
    CreatedAt = DateTime.UtcNow
});

Console.WriteLine($"Server created: {ToJsonString(server)}");
//TODO: Removed unused vars
var keeperMember = await db.Create("server_members", new ServerMembers
{
    UserId = keeper.Id,
    JoinedAt = DateTime.UtcNow,
    IsOwner = true
});

var kiraMember = await db.Create("server_members", new ServerMembers
{
    UserId = kira.Id,
    JoinedAt = DateTime.UtcNow,
    IsOwner = false
});

var testMember = await db.Create("server_members", new ServerMembers
{
    UserId = test.Id,
    JoinedAt = DateTime.UtcNow,
    IsOwner = false
});

Console.WriteLine("Server members created.");
//TODO: Make channels dynamically addable
//TODO: Add logic for channel types (ENUM)
//TODO: Add a test voice channel
//TODO: Add logic for channel groups for future UI use
var channel = await db.Create("channels", new Channels
{
    Name = "general",
    CreatedAt = DateTime.UtcNow
});

var channel2 = await db.Create("channels", new Channels
{
    Name = "files",
    CreatedAt = DateTime.UtcNow.Subtract(new TimeSpan(0, 4, 0, 0))
});

var channel3 = await db.Create("channels", new Channels
{
    Name = "welcome",
    CreatedAt = DateTime.UtcNow.Subtract(new TimeSpan(1, 4, 4, 4))
});

Console.WriteLine($"Channel created: {ToJsonString(channel)}");
Console.WriteLine($"Channel created: {ToJsonString(channel2)}");
Console.WriteLine($"Channel created: {ToJsonString(channel3)}");

var channelId = GetRecordId(channel.Id);
var channelId2 = GetRecordId(channel2.Id);
var channelId3 = GetRecordId(channel3.Id);

Console.WriteLine($"Resolved channelId: {channelId}");
Console.WriteLine($"Resolved channelId: {channelId2}");
Console.WriteLine($"Resolved channelId: {channelId3}");

var keyBase64 = cryptoService.GenerateKey();
var serverKeys = E2EeHelper.GenerateRsaKeyPair();

var serverKey = await db.Create("server_encryption_keys", new ServerEncryptionKeys
{
    KeyBase64 = keyBase64,
    PublicKey = serverKeys.publicKey,
    PrivateKey = serverKeys.privateKey,
    CreatedAt = DateTime.UtcNow,
    UpdatedAt = DateTime.UtcNow
});

ChatTest.ServerPublicKey = serverKeys.publicKey;
ChatTest.ServerPrivateKey = serverKeys.privateKey;
ChatTest.ChannelDbKey = keyBase64;

Console.WriteLine("Server encryption key created.");

await app.StartAsync();

Console.ReadKey(true); //TODO: Make program stop be a console command rather than just [RETURN]

wssv.Stop();
await app.StopAsync(); 
return;

static string ToJsonString(object? obj)
{
    return JsonSerializer.Serialize(obj, new JsonSerializerOptions
    {
        WriteIndented = true,
        Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
    });
}

static string GetRecordId(object? id)
{
    if (id is null)
        return string.Empty;

    var json = JsonSerializer.Serialize(id);

    using var doc = JsonDocument.Parse(json);

    var root = doc.RootElement;

    var recordId = root.GetProperty("Id").GetString() ?? string.Empty;
    var table = root.GetProperty("Table").GetString() ?? string.Empty;

    return $"{table}:{recordId}";
}

//TODO: Cleanup unused code
public class WebRtcHub : Hub
{
    public async Task SendOffer(string targetConnectionId, string sdp)
    {
        await Clients.Client(targetConnectionId)
            .SendAsync("ReceiveOffer", Context.ConnectionId, sdp);
    }

    public async Task SendAnswer(string targetConnectionId, string sdp)
    {
        await Clients.Client(targetConnectionId)
            .SendAsync("ReceiveAnswer", Context.ConnectionId, sdp);
    }

    public async Task SendIceCandidate(string targetConnectionId, string candidate)
    {
        await Clients.Client(targetConnectionId)
            .SendAsync("ReceiveIceCandidate", Context.ConnectionId, candidate);
    }
}