Review settings and streamings

LemonBot.slnx

@@ -0,0 +1,40 @@
+<Solution>
+  <Configurations>
+    <Platform Name="Any CPU" />
+    <Platform Name="x64" />
+    <Platform Name="x86" />
+  </Configurations>
+  <Folder Name="/src/">
+    <Project Path="src/KITT.AppHost/KITT.AppHost.csproj" />
+    <Project Path="src/KITT.ServiceDefaults/KITT.ServiceDefaults.csproj" />
+    <Project Path="src/KITT.Services/KITT.Services.csproj" />
+  </Folder>
+  <Folder Name="/src/KITT/">
+    <Project Path="src/KITT.Core/KITT.Core.csproj" />
+    <Project Path="src/KITT.Telegram.Messages/KITT.Telegram.Messages.csproj" />
+    <Project Path="src/KITT.Web.App.UI/KITT.Web.App.UI.csproj" />
+    <Project Path="src/KITT.Web.App/KITT.Web.App.Client/KITT.Web.App.Client.csproj" />
+    <Project Path="src/KITT.Web.App/KITT.Web.App/KITT.Web.App.csproj" />
+    <Project Path="src/KITT.Web.Models/KITT.Web.Models.csproj" />
+    <Project Path="src/KITT.Web.Shared/KITT.Web.Shared.csproj" />
+  </Folder>
+  <Folder Name="/src/KITT/Cms/">
+    <Project Path="src/KITT.Cms.Settings/KITT.Cms.Settings.csproj" />
+    <Project Path="src/KITT.Cms.Web.Api/KITT.Cms.Web.Api.csproj" />
+    <Project Path="src/KITT.Cms.Web.App/KITT.Cms.Web.App.csproj" />
+    <Project Path="src/KITT.Cms.Web.Models/KITT.Cms.Web.Models.csproj" />
+  </Folder>
+  <Folder Name="/src/KITT/Proposals/">
+    <Project Path="src/KITT.Proposals.Web.Api/KITT.Proposals.Web.Api.csproj" />
+    <Project Path="src/KITT.Proposals.Web.App/KITT.Proposals.Web.App.csproj" />
+    <Project Path="src/KITT.Proposals.Web.Models/KITT.Proposals.Web.Models.csproj" />
+  </Folder>
+  <Folder Name="/src/KITT/Support/">
+    <Project Path="src/KITT.Support.Seeder/KITT.Support.Seeder.csproj" />
+  </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/KITT.Cms.Web.Api.Test/KITT.Cms.Web.Api.Test.csproj" />
+    <Project Path="tests/KITT.Core.Test/KITT.Core.Test.csproj" />
+    <Project Path="tests/KITT.Web.Testing/KITT.Web.Testing.csproj" />
+  </Folder>
+</Solution>

aspire.config.json

@@ -0,0 +1,5 @@
+{
+  "appHost": {
+    "path": "src/KITT.AppHost/KITT.AppHost.csproj"
+  }
+}

src/KITT.AppHost/DistributedApplicationBuilderExtensions.cs

@@ -5,22 +5,28 @@ namespace KITT.AppHost;
 
 public static class DistributedApplicationBuilderExtensions
 {
-    public static IResourceBuilder<IResourceWithConnectionString> AddKittDatabase(this IDistributedApplicationBuilder builder)
+    extension(IDistributedApplicationBuilder builder)
     {
-        ArgumentNullException.ThrowIfNull(builder);
-
-        if (!builder.ExecutionContext.IsPublishMode)
+        public IResourceBuilder<IResourceWithConnectionString> AddKittDatabase()
         {
-            var kittSql = builder.AddSqlServer(ServiceNames.Sql)
-                .WithContainerName("sqlserver-local")
-                .WithLifetime(ContainerLifetime.Persistent)
-                .WithDataVolume("kitt-data");
+            ArgumentNullException.ThrowIfNull(builder);
 
-            return kittSql.AddDatabase(ServiceNames.Database, databaseName: "KITT");
-        }
-        else
-        {
-            return builder.AddConnectionString(ServiceNames.Database);
+            if (!builder.ExecutionContext.IsPublishMode)
+            {
+                var kittSql = builder.AddSqlServer(ServiceNames.Sql)
+                    .WithDataVolume("kitt-data")
+                    .WithDbGate(containerBuilder =>
+                    {
+                        containerBuilder.WithExplicitStart();
+                    });
+
+                return kittSql.AddDatabase(ServiceNames.Database, databaseName: "KITT");
+            }
+            else
+            {
+                return builder.AddConnectionString(ServiceNames.Database);
+            }
         }
     }
+
 }

src/KITT.AppHost/KITT.AppHost.csproj

@@ -1,22 +1,21 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <Sdk Name="Aspire.AppHost.Sdk" Version="9.5.1" />
+<Project Sdk="Aspire.AppHost.Sdk/13.2.1">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <UserSecretsId>9088a778-e43f-44ea-8c00-27313c124862</UserSecretsId>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Aspire.Hosting.AppHost" Version="9.5.1" />
-    <PackageReference Include="Aspire.Hosting.Azure" Version="9.5.1" />
-    <PackageReference Include="Aspire.Hosting.Azure.AppContainers" Version="9.5.1" />
-    <PackageReference Include="Aspire.Hosting.Azure.KeyVault" Version="9.5.1" />
-    <PackageReference Include="Aspire.Hosting.Azure.Sql" Version="9.5.1" />
-    <PackageReference Include="AzureKeyVaultEmulator.Aspire.Hosting" Version="2.6.0" />
+    <PackageReference Include="Aspire.Hosting.Azure" Version="13.2.1" />
+    <PackageReference Include="Aspire.Hosting.Azure.AppContainers" Version="13.2.1" />
+    <PackageReference Include="Aspire.Hosting.Azure.KeyVault" Version="13.2.1" />
+    <PackageReference Include="Aspire.Hosting.Azure.Sql" Version="13.2.1" />
+    <PackageReference Include="Aspire.Hosting.Azure.Storage" Version="13.2.1" />
+    <PackageReference Include="AzureKeyVaultEmulator.Aspire.Hosting" Version="2.9.0" />
+    <PackageReference Include="CommunityToolkit.Aspire.Hosting.SqlServer.Extensions" Version="13.1.1" />
   </ItemGroup>
 
   <ItemGroup>

src/KITT.AppHost/Program.cs

@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Hosting;
 using KITT.Services;
 using KITT.AppHost;
+using Aspire.Hosting.Azure;
 
 var builder = DistributedApplication.CreateBuilder(args);
 
@@ -22,10 +23,37 @@
 var kittDb = builder.AddKittDatabase();
 #endregion
 
+#region Azure Storage Account
+var azureStorage = builder.AddAzureStorage(ServiceNames.DataStorageAccount)
+    .ConfigureInfrastructure(infra =>
+    {
+        var storageAccountResource = infra.GetProvisionableResources()
+            .OfType<Azure.Provisioning.Storage.StorageAccount>()
+            .SingleOrDefault();
+
+        if (storageAccountResource is not null)
+        {
+            storageAccountResource.Kind = Azure.Provisioning.Storage.StorageKind.StorageV2;
+            storageAccountResource.Sku = new()
+            {
+                Name = Azure.Provisioning.Storage.StorageSkuName.StandardLrs
+            };
+        }
+    })
+    .RunAsEmulator(azurite =>
+    {
+        azurite.WithDataVolume("kittdatastorage-data");
+    });
+
+var settingsTables = azureStorage.AddTables(ServiceNames.SettingsTables);
+#endregion
+
 #region CMS
 var cmsApi = builder.AddProject<Projects.KITT_Cms_Web_Api>(ServiceNames.CmsApi)
     .WithReference(kittDb)
     .WaitFor(kittDb)
+    .WithReference(settingsTables)
+    .WaitFor(settingsTables)
     .WithEnvironment("Identity__TenantId", tenantId)
     .WithEnvironment("Identity__Cms__AppId", cmsApiAppId)
     .PublishAsAzureContainerApp((_, app) =>

src/KITT.Cms.Settings/ConnectedChannelsRepository.cs

@@ -0,0 +1,54 @@
+using Azure.Data.Tables;
+using KITT.Cms.Settings.Models;
+
+namespace KITT.Cms.Settings;
+
+public class ConnectedChannelsRepository : IConnectedChannelsRepository
+{
+    private readonly TableClient _tableClient;
+
+    internal const string ConnectedChannelsTableName = "SettingsChannels";
+
+    public ConnectedChannelsRepository(TableServiceClient tableServiceClient)
+    {
+        ArgumentNullException.ThrowIfNull(tableServiceClient);
+        _tableClient = CreateTableIfNotExist(tableServiceClient) ?? throw new ArgumentNullException("tableClient");
+    }
+
+    private static TableClient? CreateTableIfNotExist(TableServiceClient tableServiceClient)
+    {
+        var tableClient = tableServiceClient.GetTableClient(ConnectedChannelsTableName);
+        tableClient.CreateIfNotExists();
+
+        return tableClient;
+    }
+
+    public async Task<ConnectedChannel[]> GetConnectedChannelsAsync(string userId)
+    {
+        var channelsQuery = _tableClient.QueryAsync<ConnectedChannel>(c => c.PartitionKey == userId);
+        var channels = new List<ConnectedChannel>();
+
+        await foreach (var channel in channelsQuery)
+        {
+            channels.Add(channel);
+        }
+
+        return channels.OrderBy(c => c.Name).ToArray();
+    }
+
+    public Task<ConnectedChannel?> GetConnectedChannelAsync(Guid channelId, string userId)
+    {
+        var channels = _tableClient.Query<ConnectedChannel>(c => c.PartitionKey == userId && c.RowKey == channelId.ToString());
+        return Task.FromResult(channels.SingleOrDefault());
+    }
+
+    public async Task SaveAsync(ConnectedChannel channel)
+    {
+        await _tableClient.UpsertEntityAsync(channel, TableUpdateMode.Replace);
+    }
+
+    public async Task DeleteAsync(Guid channelId, string userId)
+    {
+        await _tableClient.DeleteEntityAsync(userId, channelId.ToString());
+    }
+}

src/KITT.Cms.Settings/IConnectedChannelsRepository.cs

@@ -0,0 +1,14 @@
+using KITT.Cms.Settings.Models;
+
+namespace KITT.Cms.Settings;
+
+public interface IConnectedChannelsRepository
+{
+    Task<ConnectedChannel[]> GetConnectedChannelsAsync(string userId);
+
+    Task<ConnectedChannel?> GetConnectedChannelAsync(Guid channelId, string userId);
+
+    Task SaveAsync(ConnectedChannel channel);
+
+    Task DeleteAsync(Guid channelId, string userId);
+}

src/KITT.Cms.Settings/KITT.Cms.Settings.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Azure.Data.Tables" Version="12.11.0" />
+  </ItemGroup>
+
+</Project>

src/KITT.Cms.Settings/Models/ChannelType.cs

@@ -0,0 +1,7 @@
+namespace KITT.Cms.Settings.Models;
+
+public enum ChannelType
+{
+    Twitch,
+    YouTube
+}

src/KITT.Cms.Settings/Models/ConnectedChannel.cs

@@ -0,0 +1,21 @@
+using Azure;
+using Azure.Data.Tables;
+
+namespace KITT.Cms.Settings.Models;
+
+public class ConnectedChannel : ITableEntity
+{
+    public required string PartitionKey { get; set; } = string.Empty;
+
+    public required string RowKey { get; set; } = string.Empty;
+
+    public DateTimeOffset? Timestamp { get; set; }
+
+    public ETag ETag { get; set; }
+
+    public required string Name { get; set; } = string.Empty;
+
+    public required string Url { get; set; } = string.Empty;
+
+    public required ChannelType Type { get; set; }
+}

src/KITT.Cms.Web.Api/Endpoints/Services/ChannelsEndpointsServices.cs

@@ -0,0 +1,79 @@
+using KITT.Cms.Settings;
+using KITT.Cms.Settings.Models;
+using KITT.Cms.Web.Models.Settings;
+
+namespace KITT.Cms.Web.Api.Endpoints.Services;
+
+public class ChannelsEndpointsServices(IConnectedChannelsRepository connectedChannelsRepository)
+{
+    public async Task<ChannelModel[]> GetChannelsAsync(string userId)
+    {
+        var channels = await connectedChannelsRepository.GetConnectedChannelsAsync(userId);
+        return channels.Select(c => new ChannelModel
+        {
+            Id = Guid.Parse(c.RowKey),
+            Name = c.Name,
+            Url = c.Url,
+            Type = c.Type
+        }).ToArray();
+    }
+
+    public async Task<ChannelModel?> GetChannelAsync(Guid channelId, string userId)
+    {
+        var channel = await connectedChannelsRepository.GetConnectedChannelAsync(channelId, userId);
+        if (channel is null)
+        {
+            return null;
+        }
+
+        return new ChannelModel
+        {
+            Id = Guid.Parse(channel.RowKey),
+            Name = channel.Name,
+            Url = channel.Url,
+            Type = channel.Type
+        };
+    }
+
+    public async Task<ChannelModel> CreateChannelAsync(ChannelModel model, string userId)
+    {
+        model.Id = Guid.NewGuid();
+
+        var channelEntity = MapToConnectedChannel(model, userId);
+        await connectedChannelsRepository.SaveAsync(channelEntity);
+
+        return model;
+    }
+
+    public async Task DeleteChannelAsync(Guid channelId, string userId)
+    {
+        await connectedChannelsRepository.DeleteAsync(channelId, userId);
+    }
+
+    public async Task UpdateChannelAsync(Guid channelId, ChannelModel model, string userId)
+    {
+        var connectedChannel = await connectedChannelsRepository.GetConnectedChannelAsync(channelId, userId);
+        if (connectedChannel is null)
+        {
+            throw new ArgumentOutOfRangeException(nameof(channelId));
+        }
+
+        connectedChannel.Name = model.Name;
+        connectedChannel.Url = model.Url;
+        connectedChannel.Type = model.Type;
+
+        await connectedChannelsRepository.SaveAsync(connectedChannel);
+    }
+
+    private static ConnectedChannel MapToConnectedChannel(ChannelModel model, string userId)
+    {
+        return new()
+        {
+            RowKey = model.Id.ToString(),
+            PartitionKey = userId,
+            Name = model.Name,
+            Url = model.Url,
+            Type = model.Type
+        };
+    }
+}