Add WebhookPayloadProviders

src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Collections.cs

@@ -106,7 +106,7 @@ internal static void AddAllCoreCollectionBuilders(this IUmbracoBuilder builder)
         }
 
         builder.WebhookEvents().AddCms(true, webhookPayloadType);
-
+        builder.WebhookPayloadProviders();
         builder.ContentTypeFilters();
     }
 
@@ -269,4 +269,7 @@ public static ContentIndexHandlerCollectionBuilder ContentIndexHandlers(this IUm
     /// <param name="builder">The builder.</param>
     public static ContentTypeFilterCollectionBuilder ContentTypeFilters(this IUmbracoBuilder builder)
         => builder.WithCollectionBuilder<ContentTypeFilterCollectionBuilder>();
+
+    public static WebhookPayloadProviderCollectionBuilder WebhookPayloadProviders(this IUmbracoBuilder builder)
+        => builder.WithCollectionBuilder<WebhookPayloadProviderCollectionBuilder>();
 }

src/Umbraco.Core/Webhooks/IWebhookPayloadProvider.cs

@@ -0,0 +1,8 @@
+namespace Umbraco.Cms.Core.Webhooks;
+
+public interface IWebhookPayloadProvider
+{
+    bool CanHandle(WebhookContext ctx);
+
+    object BuildPayload(WebhookContext ctx);
+}

src/Umbraco.Core/Webhooks/WebhookContext.cs

@@ -0,0 +1,9 @@
+using Umbraco.Cms.Core.Models;
+
+namespace Umbraco.Cms.Core.Webhooks;
+public sealed record WebhookContext(
+    Uri Endpoint,
+    string EventAlias,
+    object Notification,
+    IWebhook Webhook
+);

src/Umbraco.Core/Webhooks/WebhookEventBase.cs

@@ -1,6 +1,9 @@
+using System.Net;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 
 using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Notifications;
@@ -15,6 +18,8 @@ public abstract class WebhookEventBase<TNotification> : IWebhookEvent, INotifica
 {
     private readonly IServerRoleAccessor _serverRoleAccessor;
 
+    private readonly WebhookPayloadProviderCollection _webhookPayloadProviderCollection;
+
     public abstract string Alias { get; }
 
     public string EventName { get; set; }
@@ -34,11 +39,25 @@ protected WebhookEventBase(
         IWebhookService webhookService,
         IOptionsMonitor<WebhookSettings> webhookSettings,
         IServerRoleAccessor serverRoleAccessor)
+        : this(
+            webhookFiringService,
+            webhookService, webhookSettings, serverRoleAccessor,
+            StaticServiceProvider.Instance.GetRequiredService<WebhookPayloadProviderCollection>())
     {
+    }
+
 
+    protected WebhookEventBase(
+        IWebhookFiringService webhookFiringService,
+        IWebhookService webhookService,
+        IOptionsMonitor<WebhookSettings> webhookSettings,
+        IServerRoleAccessor serverRoleAccessor,
+        WebhookPayloadProviderCollection webhookPayloadProviderCollection)
+    {
         WebhookFiringService = webhookFiringService;
         WebhookService = webhookService;
         _serverRoleAccessor = serverRoleAccessor;
+        _webhookPayloadProviderCollection = webhookPayloadProviderCollection;
 
         // assign properties based on the attribute, if it is found
         WebhookEventAttribute? attribute = GetType().GetCustomAttribute<WebhookEventAttribute>(false);
@@ -62,8 +81,29 @@ public virtual async Task ProcessWebhooks(TNotification notification, IEnumerabl
                 continue;
             }
 
-            await WebhookFiringService.FireAsync(webhook, Alias, ConvertNotificationToRequestPayload(notification), cancellationToken);
+            if (!Uri.TryCreate(webhook.Url, UriKind.Absolute, out Uri? endPoint))
+            {
+                continue;
+            }
+            var ctx = new WebhookContext(endPoint, Alias, notification, webhook);
+
+            IWebhookPayloadProvider? provider = GetPayloadProviderProvider(notification, webhook);
+            var payload = provider is null
+                ? ConvertNotificationToRequestPayload(notification)
+                : provider.BuildPayload(ctx);
+
+            await WebhookFiringService.FireAsync(webhook, Alias, payload, cancellationToken);
+        }
+    }
+
+    protected IWebhookPayloadProvider? GetPayloadProviderProvider(TNotification notification, IWebhook webhook)
+    {
+        if (!Uri.TryCreate(webhook.Url, UriKind.Absolute, out Uri? endPoint))
+        {
+            return null;
         }
+        var ctx = new WebhookContext(endPoint, Alias, notification, webhook);
+        return _webhookPayloadProviderCollection.FirstOrDefault(x => x.CanHandle(ctx));
     }
 
     /// <summary>

src/Umbraco.Core/Webhooks/WebhookEventContentBase.cs

@@ -1,3 +1,4 @@
+using System.Net;
 using Microsoft.Extensions.Options;
 
 using Umbraco.Cms.Core.Configuration.Models;
@@ -37,7 +38,19 @@
                     continue;
                 }
 
-                await WebhookFiringService.FireAsync(webhook, Alias, ConvertEntityToRequestPayload(entity), cancellationToken);
+                if (!Uri.TryCreate(webhook.Url, UriKind.Absolute, out Uri? endPoint))
+                {
+                    continue;
+                }
+
+                var ctx = new WebhookContext(endPoint, Alias, notification, webhook);
+
+                IWebhookPayloadProvider? provider = GetPayloadProviderProvider(notification, webhook);
+                var payload = provider is null
+                    ? ConvertEntityToRequestPayload(entity)
+                    : provider.BuildPayload(ctx);
+
+                await WebhookFiringService.FireAsync(webhook, Alias, payload, cancellationToken);
             }
         }
     }

src/Umbraco.Core/Webhooks/WebhookPayloadProviderBase.cs

@@ -0,0 +1,15 @@
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Notifications;
+
+namespace Umbraco.Cms.Core.Webhooks;
+
+public abstract class WebhookPayloadProviderBase<TNotification> : IWebhookPayloadProvider where TNotification : class, INotification
+{
+    public bool CanHandle(WebhookContext ctx) => ctx.Notification is TNotification n && CanHandle(ctx.Endpoint, ctx.EventAlias, n, ctx.Webhook);
+
+    object IWebhookPayloadProvider.BuildPayload(WebhookContext ctx)
+        => BuildPayload((TNotification)ctx.Notification, ctx.Endpoint, ctx.EventAlias, ctx.Webhook);
+
+    protected abstract bool CanHandle(Uri endpoint, string eventAlias, TNotification notification, IWebhook webhook);
+    protected abstract object BuildPayload(TNotification notification, Uri endpoint, string eventAlias, IWebhook webhook);
+}

src/Umbraco.Core/Webhooks/WebhookPayloadProviderCollection.cs

@@ -0,0 +1,5 @@
+using Umbraco.Cms.Core.Composing;
+
+namespace Umbraco.Cms.Core.Webhooks;
+
+public class WebhookPayloadProviderCollection(Func<IEnumerable<IWebhookPayloadProvider>> items) : BuilderCollectionBase<IWebhookPayloadProvider>(items);

src/Umbraco.Core/Webhooks/WebhookPayloadProviderCollectionBuilder.cs

@@ -0,0 +1,8 @@
+using Umbraco.Cms.Core.Composing;
+
+namespace Umbraco.Cms.Core.Webhooks;
+
+public class WebhookPayloadProviderCollectionBuilder : LazyCollectionBuilderBase<WebhookPayloadProviderCollectionBuilder, WebhookPayloadProviderCollection, IWebhookPayloadProvider>
+{
+    protected override WebhookPayloadProviderCollectionBuilder This => this;
+}

src/Umbraco.Web.UI/MyComposer.cs

@@ -0,0 +1,12 @@
+using Umbraco.Cms.Core.Composing;
+using Umbraco.Cms.Core.Webhooks;
+
+namespace Umbraco.Cms.Web.UI;
+
+public class MyComposer : IComposer
+{
+    public void Compose(IUmbracoBuilder builder)
+    {
+        builder.WithCollectionBuilder<WebhookPayloadProviderCollectionBuilder>().Add<MyCustomWebhookPayloadProvider>();
+    }
+}

src/Umbraco.Web.UI/MyCustomWebhookPayloadProvider.cs

@@ -0,0 +1,20 @@
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Notifications;
+using Umbraco.Cms.Core.Webhooks;
+
+namespace Umbraco.Cms.Web.UI;
+
+public class MyCustomWebhookPayloadProvider : WebhookPayloadProviderBase<ContentPublishedNotification>
+{
+    protected override bool CanHandle(Uri endpoint, string eventAlias, ContentPublishedNotification notification,
+        IWebhook webhook)
+    {
+        var host = endpoint.Host.ToLowerInvariant();
+        var isWebhookSite = host.Contains("webhook.site");
+        return isWebhookSite;
+    }
+
+    protected override object BuildPayload(ContentPublishedNotification notification, Uri endpoint, string eventAlias,
+        IWebhook webhook)
+        => new {messgage = "Published new Content"};
+}