Refactored to use a single action that accepts an array (the model binder will bind a single object as a one-element array).

Fixed default event to error more gracefully.

Author: BillVolz

src/SocketLabs.EventWebhooks.Extensions/Controllers/WebhookEventsController.cs

@@ -27,42 +27,7 @@ IOptionsMonitor<WebhookOptions> options
         }
 
         [HttpPost]
-        public async Task<IActionResult> Post(WebhookEventBase webhookEvent, string id)
-        {
-            if (!_options.TryGetWebhook(id, out var endpoint) || endpoint?.SecretKey != webhookEvent.SecretKey)
-            {
-                return Unauthorized();
-            }
-
-            try
-            {
-                webhookEvent.WebhookEndpointName = id;
-
-                Task result = webhookEvent switch
-                {
-                    ComplaintEvent eventItem => ProcessEvent(eventItem),
-                    DeferredEvent eventItem => ProcessEvent(eventItem),
-                    EngagementEvent eventItem => ProcessEvent(eventItem),
-                    FailedEvent eventItem => ProcessEvent(eventItem),
-                    QueuedEvent eventItem => ProcessEvent(eventItem),
-                    SentEvent eventItem => ProcessEvent(eventItem),
-                    ValidationEvent eventItem => ProcessEvent(eventItem),
-                    _ => throw new InvalidOperationException("Unable to convert event type.")
-                };
-
-                await result;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Unable to process webhook event.");
-
-                return BadRequest();
-            }
-
-            return Ok();
-        }
-        [HttpPost]
-        public async Task<IActionResult> Post(WebhookEventBase[] webhookEvents, string id)
+        public async Task<IActionResult> Post([FromBody] WebhookEventBase[] webhookEvents, string id)
         {
             foreach (var webhookEvent in webhookEvents)
             {
@@ -75,7 +40,7 @@ public async Task<IActionResult> Post(WebhookEventBase[] webhookEvents, string i
                 {
                     webhookEvent.WebhookEndpointName = id;
 
-                    Task result = webhookEvent switch
+                    Task? result = webhookEvent switch
                     {
                         ComplaintEvent eventItem => ProcessEvent(eventItem),
                         DeferredEvent eventItem => ProcessEvent(eventItem),
@@ -84,65 +49,70 @@ public async Task<IActionResult> Post(WebhookEventBase[] webhookEvents, string i
                         QueuedEvent eventItem => ProcessEvent(eventItem),
                         SentEvent eventItem => ProcessEvent(eventItem),
                         ValidationEvent eventItem => ProcessEvent(eventItem),
-                        _ => throw new InvalidOperationException("Unable to convert event type.")
+                        _ => null
                     };
 
+                    if (result == null)
+                    {
+                        _logger.LogError("Unable to convert event type: {EventType} for MessageId: {MessageId}", webhookEvent.GetType().Name, webhookEvent.MessageId);
+                        return BadRequest($"Unknown event type: {webhookEvent.GetType().Name}");
+                    }
                     await result;
                 }
                 catch (Exception ex)
                 {
                     _logger.LogError(ex, "Unable to process webhook event.");
                     return BadRequest();
                 }
-
             }
 
             return Ok();
         }
 
-        private async Task ProcessEvent(ComplaintEvent webhookEvent)
+
+        private async Task? ProcessEvent(ComplaintEvent webhookEvent)
         {
             webhookEvent.Type = "Complaint";
             _logger.LogTrace("Begin processing webhook event for {SystemMessageId}", webhookEvent.MessageId);
             await _webhookEventHandler.ProcessAsync(webhookEvent);
         }
 
-        private async Task ProcessEvent(DeferredEvent webhookEvent)
+        private async Task? ProcessEvent(DeferredEvent webhookEvent)
         {
             webhookEvent.Type = "Deferred";
             _logger.LogTrace("Begin processing webhook event for {SystemMessageId}", webhookEvent.MessageId);
             await _webhookEventHandler.ProcessAsync(webhookEvent);
         }
 
-        private async Task ProcessEvent(EngagementEvent webhookEvent)
+        private async Task? ProcessEvent(EngagementEvent webhookEvent)
         {
             webhookEvent.Type = "Tracking";
             _logger.LogTrace("Begin processing webhook event for {SystemMessageId}", webhookEvent.MessageId);
             await _webhookEventHandler.ProcessAsync(webhookEvent);
         }
 
-        private async Task ProcessEvent(FailedEvent webhookEvent)
+        private async Task? ProcessEvent(FailedEvent webhookEvent)
         {
             webhookEvent.Type = "Failed";
             _logger.LogTrace("Begin processing webhook event for {SystemMessageId}", webhookEvent.MessageId);
             await _webhookEventHandler.ProcessAsync(webhookEvent);
         }
 
-        private async Task ProcessEvent(QueuedEvent webhookEvent)
+        private async Task? ProcessEvent(QueuedEvent webhookEvent)
         {
             webhookEvent.Type = "Queued";
             _logger.LogTrace("Begin processing webhook event for {SystemMessageId}", webhookEvent.MessageId);
             await _webhookEventHandler.ProcessAsync(webhookEvent);
         }
 
-        private async Task ProcessEvent(SentEvent webhookEvent)
+        private async Task? ProcessEvent(SentEvent webhookEvent)
         {
             webhookEvent.Type = "Delivered";
             _logger.LogTrace("Begin processing webhook event for {SystemMessageId}", webhookEvent.MessageId);
             await _webhookEventHandler.ProcessAsync(webhookEvent);
         }
 
-        private async Task ProcessEvent(ValidationEvent webhookEvent)
+        private async Task? ProcessEvent(ValidationEvent webhookEvent)
         {
             webhookEvent.Type = "Validation";
             _logger.LogTrace("Begin processing webhook event for {SystemMessageId}", webhookEvent.MessageId);