private async Task SendWebHookAsync(WebHook webHook, WebHookNotificationContext context)
{
try
{
// Setup and send WebHook request
var request = await CreateWebHookRequestAsync(webHook, context);
var clientName = webHook.ValidateSsl ? "webhooks" : "webhooks_insecure";
var client = _clientFactory.CreateClient(clientName);
if (Logger.IsEnabled(LogLevel.Debug))
{
var contentMessage = $"Sending webHook '{webHook.Id}' with body '{await request.Content.ReadAsStringAsync()}'.";
Logger.LogDebug(contentMessage);
}
var response = await client.SendAsync(request);
var message = $"WebHook '{webHook.Id}' resulted in status code '{response.StatusCode}'.";
Logger.LogInformation(message);
}
catch (Exception ex)
{
var message = $"Failed to submit WebHook {webHook.Id} due to failure: {ex.Message}";
Logger.LogError(message, ex);
}
}
public async Task NotifyAsync(string eventName, JObject defaultPayload, Dictionary <string, object> properties)
{
if (eventName == null)
{
throw new ArgumentNullException(nameof(eventName));
}
try
{
// Get all WebHooks for tenant
var webHooksList = await _store.GetAllWebHooksAsync();
// Match any webhooks against the triggered event e.g. *.*, content.created, asset.updated
var matchedWebHooks = webHooksList.WebHooks.Where(x => x.Enabled && x.MatchesEvent(eventName));
var context = new WebHookNotificationContext
{
EventName = eventName,
DefaultPayload = defaultPayload ?? new JObject(),
Properties = properties ?? new Dictionary <string, object>()
};
// Send the notification to the matching webhooks
await _sender.SendNotificationsAsync(matchedWebHooks, context);
}
catch (Exception ex)
{
var message = $"Failed to notify of webhook event {eventName} due to failure: {ex.Message}";
Logger.LogError(message, ex);
}
}
public async Task <JObject> RenderAsync(WebHook webHook, WebHookNotificationContext context)
{
var templateContext = _liquidTemplateManager.Context;// await CreateTemplateContextAsync(webHook, context);
var result = await _liquidTemplateManager.RenderAsync(webHook.PayloadTemplate, NullEncoder.Default, templateContext);
return(string.IsNullOrWhiteSpace(result) ? new JObject() : JObject.Parse(result));
}
/// <inheritdoc />
public Task SendNotificationsAsync(IEnumerable <WebHook> webHooks, WebHookNotificationContext context)
{
if (webHooks == null)
{
throw new ArgumentNullException(nameof(webHooks));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// Send all webhooks in parallel
return(Task.WhenAll(webHooks.Select(webHook => SendWebHookAsync(webHook, context))));
}
/// <summary>
/// Creates an <see cref="HttpRequestMessage"/> containing the headers and body given a <paramref name="webHook"/>.
/// </summary>
/// <param name="webHook">A <see cref="WebHook"/> to be sent.</param>
/// <param name="context"></param>
/// <returns>A filled in <see cref="HttpRequestMessage"/>.</returns>
protected virtual async Task <HttpRequestMessage> CreateWebHookRequestAsync(WebHook webHook, WebHookNotificationContext context)
{
if (webHook == null)
{
throw new ArgumentNullException(nameof(webHook));
}
// Create WebHook request
var request = new HttpRequestMessage(new HttpMethod(webHook.HttpMethod), webHook.Url);
// Override the default payload if a liquid template has been provided
var payload = context.DefaultPayload;
if (!string.IsNullOrEmpty(webHook.PayloadTemplate))
{
payload = await _expressionEvaluator.RenderAsync(webHook, context);
}
// Fill in request body based on WebHook and payload
request.Content = CreateWebHookRequestBody(webHook, payload);
await SignWebHookRequestAsync(webHook, request);
AddWebHookMetadata(webHook, context.EventName, request);
AddCustomHeaders(webHook, request);
return(request);
}
