Refactored Slack and Webhook integrations to pull configurations dynamically from a new Repository

src/Core/AdminConsole/Enums/IntegrationType.cs

@@ -0,0 +1,7 @@
+namespace Bit.Core.Enums;
+
+public enum IntegrationType : int
+{
+    Slack = 1,
+    Webhook = 2,
+}

src/Core/AdminConsole/Models/Data/Integrations/IntegrationConfiguration.cs

@@ -0,0 +1,7 @@
+namespace Bit.Core.Models.Data.Integrations;
+
+public class IntegrationConfiguration<T>
+{
+    public T Configuration { get; set; }
+    public string Template { get; set; } = string.Empty;
+}

src/Core/AdminConsole/Models/Data/Integrations/SlackConfiguration.cs

@@ -0,0 +1,8 @@
+namespace Bit.Core.Models.Data.Integrations;
+
+public class SlackConfiguration
+{
+    public string Token { get; set; } = string.Empty;
+    public List<string> Channels { get; set; } = new();
+    public List<string> UserEmails { get; set; } = new();
+}

src/Core/AdminConsole/Models/Data/Integrations/WebhookConfiguration.cs

@@ -0,0 +1,7 @@
+namespace Bit.Core.Models.Data.Integrations;
+
+public class WebhookConfiguration
+{
+    public string Url { get; set; } = string.Empty;
+    public string ApiKey { get; set; } = string.Empty;
+}

src/Core/AdminConsole/Repositories/IOrganizationIntegrationConfigurationRepository.cs

@@ -0,0 +1,15 @@
+using Bit.Core.Enums;
+using Bit.Core.Models.Data.Integrations;
+
+#nullable enable
+
+namespace Bit.Core.Repositories;
+
+public interface IOrganizationIntegrationConfigurationRepository
+{
+    Task<IntegrationConfiguration<T>?> GetConfigurationAsync<T>(Guid organizationId, IntegrationType integrationType, EventType eventType);
+    Task<IEnumerable<IntegrationConfiguration<T>>> GetAllConfigurationsAsync<T>(Guid organizationId);
+    Task AddConfigurationAsync<T>(Guid organizationId, IntegrationType integrationType, EventType eventType, IntegrationConfiguration<T> configuration);
+    Task UpdateConfigurationAsync<T>(IntegrationConfiguration<T> configuration);
+    Task DeleteConfigurationAsync(Guid id);
+}

src/Core/AdminConsole/Repositories/OrganizationIntegrationConfigurationRepository.cs

@@ -0,0 +1,65 @@
+using Bit.Core.Enums;
+using Bit.Core.Models.Data.Integrations;
+using Bit.Core.Settings;
+
+namespace Bit.Core.Repositories;
+
+#nullable enable
+
+public class OrganizationIntegrationConfigurationRepository(GlobalSettings globalSettings)
+    : IOrganizationIntegrationConfigurationRepository
+{
+    private readonly string _slackToken = globalSettings.EventLogging.SlackToken;
+    private readonly string _slackUserEmail = globalSettings.EventLogging.SlackUserEmail;
+    private readonly string _webhookUrl = globalSettings.EventLogging.WebhookUrl;
+
+    public async Task<IntegrationConfiguration<T>?> GetConfigurationAsync<T>(
+        Guid organizationId,
+        IntegrationType integrationType,
+        EventType eventType)
+    {
+        switch (integrationType)
+        {
+            case IntegrationType.Slack:
+                if (string.IsNullOrWhiteSpace(_slackToken) || string.IsNullOrWhiteSpace(_slackUserEmail))
+                {
+                    return null;
+                }
+                return new IntegrationConfiguration<SlackConfiguration>()
+                {
+                    Configuration = new SlackConfiguration
+                    {
+                        Token = _slackToken,
+                        Channels = new List<string> { },
+                        UserEmails = new List<string> { _slackUserEmail }
+                    },
+                    Template = "This is a test of the new Slack integration"
+                } as IntegrationConfiguration<T>;
+            case IntegrationType.Webhook:
+                if (string.IsNullOrWhiteSpace(_webhookUrl))
+                {
+                    return null;
+                }
+                return new IntegrationConfiguration<WebhookConfiguration>()
+                {
+                    Configuration = new WebhookConfiguration()
+                    {
+                        Url = _webhookUrl,
+                    },
+                    Template = "{ \"newObject\": true }"
+                } as IntegrationConfiguration<T>;
+            default:
+                return null;
+        }
+    }
+
+    public async Task<IEnumerable<IntegrationConfiguration<T>>> GetAllConfigurationsAsync<T>(Guid organizationId) => throw new NotImplementedException();
+
+    public async Task AddConfigurationAsync<T>(Guid organizationId, IntegrationType integrationType, EventType eventType,
+        IntegrationConfiguration<T> configuration) =>
+        throw new NotImplementedException();
+
+    public async Task UpdateConfigurationAsync<T>(IntegrationConfiguration<T> configuration) => throw new NotImplementedException();
+
+    public async Task DeleteConfigurationAsync(Guid id) => throw new NotImplementedException();
+}

src/Core/AdminConsole/Services/Implementations/SlackEventHandler.cs

@@ -1,32 +1,38 @@
-using System.Text.Json;
+using Bit.Core.Enums;
 using Bit.Core.Models.Data;
-using Bit.Core.Settings;
+using Bit.Core.Models.Data.Integrations;
+using Bit.Core.Repositories;
 
 namespace Bit.Core.Services;
 
 public class SlackEventHandler(
-    GlobalSettings globalSettings,
+    IOrganizationIntegrationConfigurationRepository configurationRepository,
-    SlackMessageSender slackMessageSender)
+    SlackMessageSender slackMessageSender
-    : IEventMessageHandler
+    ) : IEventMessageHandler
 {
-    private readonly string _token = globalSettings.EventLogging.SlackToken;
-    private readonly string _email = globalSettings.EventLogging.SlackUserEmail;
-
     public async Task HandleEventAsync(EventMessage eventMessage)
     {
-        await slackMessageSender.SendDirectMessageByEmailAsync(
+        Guid organizationId = eventMessage.OrganizationId ?? Guid.NewGuid();
-            _token,
+
-            JsonSerializer.Serialize(eventMessage),
+        var configuration = await configurationRepository.GetConfigurationAsync<SlackConfiguration>(
-            _email
+            organizationId,
-        );
+            IntegrationType.Slack,
+            eventMessage.Type);
+        if (configuration is not null)
+        {
+            await slackMessageSender.SendDirectMessageByEmailAsync(
+                configuration.Configuration.Token,
+                configuration.Template,
+                configuration.Configuration.UserEmails.First()
+            );
+        }
     }
 
     public async Task HandleManyEventsAsync(IEnumerable<EventMessage> eventMessages)
     {
-        await slackMessageSender.SendDirectMessageByEmailAsync(
+        foreach (var eventMessage in eventMessages)
-            _token,
+        {
-            JsonSerializer.Serialize(eventMessages),
+            await HandleEventAsync(eventMessage);
-            _email
+        }
-        );
     }
 }

src/Core/AdminConsole/Services/Implementations/WebhookEventHandler.cs

@@ -1,30 +1,45 @@
 using System.Net.Http.Json;
+using Bit.Core.Enums;
 using Bit.Core.Models.Data;
-using Bit.Core.Settings;
+using Bit.Core.Models.Data.Integrations;
+using Bit.Core.Repositories;
+
+#nullable enable
 
 namespace Bit.Core.Services;
 
 public class WebhookEventHandler(
     IHttpClientFactory httpClientFactory,
-    GlobalSettings globalSettings)
+    IOrganizationIntegrationConfigurationRepository configurationRepository)
     : IEventMessageHandler
 {
     private readonly HttpClient _httpClient = httpClientFactory.CreateClient(HttpClientName);
-    private readonly string _webhookUrl = globalSettings.EventLogging.WebhookUrl;
 
     public const string HttpClientName = "WebhookEventHandlerHttpClient";
 
     public async Task HandleEventAsync(EventMessage eventMessage)
     {
-        var content = JsonContent.Create(eventMessage);
+        Guid organizationId = eventMessage.OrganizationId ?? Guid.NewGuid();
-        var response = await _httpClient.PostAsync(_webhookUrl, content);
+
-        response.EnsureSuccessStatusCode();
+        var configuration = await configurationRepository.GetConfigurationAsync<WebhookConfiguration>(
+            organizationId,
+            IntegrationType.Webhook,
+            eventMessage.Type);
+        if (configuration is not null)
+        {
+            var content = JsonContent.Create(configuration.Template);
+            var response = await _httpClient.PostAsync(
+                configuration.Configuration.Url,
+                content);
+            response.EnsureSuccessStatusCode();
+        }
     }
 
     public async Task HandleManyEventsAsync(IEnumerable<EventMessage> eventMessages)
     {
-        var content = JsonContent.Create(eventMessages);
+        foreach (var eventMessage in eventMessages)
-        var response = await _httpClient.PostAsync(_webhookUrl, content);
+        {
-        response.EnsureSuccessStatusCode();
+            await HandleEventAsync(eventMessage);
+        }
     }
 }

src/Core/Core.csproj

@@ -74,6 +74,7 @@
   </ItemGroup>
   
   <ItemGroup>
+    <Folder Include="AdminConsole\Utilities\" />
     <Folder Include="Resources\" />
     <Folder Include="Properties\" />
   </ItemGroup>

src/Events/Startup.cs

@@ -2,6 +2,7 @@
 using Bit.Core.AdminConsole.Services.Implementations;
 using Bit.Core.Context;
 using Bit.Core.IdentityServer;
+using Bit.Core.Repositories;
 using Bit.Core.Services;
 using Bit.Core.Settings;
 using Bit.Core.Utilities;
@@ -117,33 +118,26 @@ public class Startup
                     globalSettings,
                     globalSettings.EventLogging.RabbitMq.EventRepositoryQueueName));
 
-            if (CoreHelpers.SettingHasValue(globalSettings.EventLogging.SlackToken) &&
+            services.AddSingleton<IOrganizationIntegrationConfigurationRepository, OrganizationIntegrationConfigurationRepository>();
-                CoreHelpers.SettingHasValue(globalSettings.EventLogging.SlackUserEmail))
-            {
-                services.AddHttpClient(SlackMessageSender.HttpClientName);
-                services.AddSingleton<SlackMessageSender>();
-                services.AddSingleton<SlackEventHandler>();
 
-                services.AddSingleton<IHostedService>(provider =>
+            services.AddHttpClient(SlackMessageSender.HttpClientName);
-                    new RabbitMqEventListenerService(
+            services.AddSingleton<SlackMessageSender>();
-                        provider.GetRequiredService<SlackEventHandler>(),
+            services.AddSingleton<SlackEventHandler>();
-                        provider.GetRequiredService<ILogger<RabbitMqEventListenerService>>(),
-                        globalSettings,
-                        globalSettings.EventLogging.RabbitMq.SlackQueueName));
-            }
 
-            if (CoreHelpers.SettingHasValue(globalSettings.EventLogging.WebhookUrl))
+            services.AddSingleton<IHostedService>(provider =>
-            {
+                new RabbitMqEventListenerService(
-                services.AddSingleton<WebhookEventHandler>();
+                    provider.GetRequiredService<SlackEventHandler>(),
-                services.AddHttpClient(WebhookEventHandler.HttpClientName);
+                    provider.GetRequiredService<ILogger<RabbitMqEventListenerService>>(),
+                    globalSettings,
+                    globalSettings.EventLogging.RabbitMq.SlackQueueName));
 
-                services.AddSingleton<IHostedService>(provider =>
+            services.AddSingleton<WebhookEventHandler>();
-                    new RabbitMqEventListenerService(
+            services.AddSingleton<IHostedService>(provider =>
-                        provider.GetRequiredService<WebhookEventHandler>(),
+                new RabbitMqEventListenerService(
-                        provider.GetRequiredService<ILogger<RabbitMqEventListenerService>>(),
+                    provider.GetRequiredService<WebhookEventHandler>(),
-                        globalSettings,
+                    provider.GetRequiredService<ILogger<RabbitMqEventListenerService>>(),
-                        globalSettings.EventLogging.RabbitMq.WebhookQueueName));
+                    globalSettings,
-            }
+                    globalSettings.EventLogging.RabbitMq.WebhookQueueName));
         }
     }