private void CallWebHooks(ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateWebhookKind kind, String objectHandler = null, Exception exception = null)
{
if (template != null)
{
using (var scope = new PnPMonitoredScope("ProvisioningTemplate WebHook Call"))
{
var webhooks = new List <ProvisioningWebhookBase>();
// Merge the webhooks at template level with those at global level
if (template.ProvisioningTemplateWebhooks != null && template.ProvisioningTemplateWebhooks.Any())
{
webhooks.AddRange(template.ProvisioningTemplateWebhooks);
}
if (template.ParentHierarchy?.ProvisioningWebhooks != null && template.ParentHierarchy.ProvisioningWebhooks.Any())
{
webhooks.AddRange(template.ParentHierarchy.ProvisioningWebhooks);
}
// If there is any webhook
if (webhooks.Count > 0)
{
foreach (var webhook in webhooks.Where(w => w.Kind == kind))
{
WebhookSender.InvokeWebhook(webhook, httpClient, kind, parser, objectHandler, exception, scope);
}
}
}
}
}
private void CallWebHooks(ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateWebhookKind kind, ObjectHandlerBase objectHandler = null)
{
using (var scope = new PnPMonitoredScope("ProvisioningTemplate WebHook Call"))
{
if (template.ProvisioningTemplateWebhooks != null && template.ProvisioningTemplateWebhooks.Any())
{
foreach (var webhook in template.ProvisioningTemplateWebhooks.Where(w => w.Kind == kind))
{
var requestParameters = new Dictionary <String, String>();
SimpleTokenParser internalParser = new SimpleTokenParser();
foreach (var webhookparam in webhook.Parameters)
{
requestParameters.Add(webhookparam.Key, parser.ParseString(webhookparam.Value));
internalParser.AddToken(new WebhookParameter(webhookparam.Key, requestParameters[webhookparam.Key]));
}
var url = parser.ParseString(webhook.Url); // parse for template scoped parameters
url = internalParser.ParseString(url); // parse for webhook scoped parameters
switch (webhook.Method)
{
case ProvisioningTemplateWebhookMethod.GET:
{
if (kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningStarted || kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningCompleted)
{
url += $"&__handler={objectHandler.InternalName}"; // add the handler name to the REST request URL
url += $"&__webhookKind={kind.ToString()}"; // add the webhook kind to the REST request URL
}
try
{
using (var client = new HttpClient())
{
if (webhook.Async)
{
client.GetAsync(url);
}
else
{
client.GetAsync(url).GetAwaiter().GetResult();
}
}
}
catch (HttpRequestException ex)
{
scope.LogError(ex, "Error calling provisioning template webhook");
}
break;
}
case ProvisioningTemplateWebhookMethod.POST:
{
requestParameters.Add("__webhookKind", kind.ToString()); // add the webhook kind to the parameters of the request body
if (kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningCompleted || kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningStarted)
{
requestParameters.Add("__handler", objectHandler.InternalName); // add the handler name to the parameters of the request body
}
try
{
using (var client = new HttpClient())
{
if (webhook.Async)
{
switch (webhook.BodyFormat)
{
case ProvisioningTemplateWebhookBodyFormat.Json:
client.PostAsJsonAsync(url, requestParameters);
break;
case ProvisioningTemplateWebhookBodyFormat.Xml:
client.PostAsXmlAsync(url, requestParameters);
break;
case ProvisioningTemplateWebhookBodyFormat.FormUrlEncoded:
var content = new FormUrlEncodedContent(requestParameters);
client.PostAsync(url, content);
break;
}
}
else
{
switch (webhook.BodyFormat)
{
case ProvisioningTemplateWebhookBodyFormat.Json:
client.PostAsJsonAsync(url, requestParameters).GetAwaiter().GetResult();
break;
case ProvisioningTemplateWebhookBodyFormat.Xml:
client.PostAsXmlAsync(url, requestParameters).GetAwaiter().GetResult();
break;
case ProvisioningTemplateWebhookBodyFormat.FormUrlEncoded:
var content = new FormUrlEncodedContent(requestParameters);
client.PostAsync(url, content).GetAwaiter().GetResult();
break;
}
}
}
}
catch (HttpRequestException ex)
{
scope.LogError(ex, "Error calling provisioning template webhook");
}
break;
}
}
}
}
}
}
/// <summary>
/// Public method to send a Webhook notification
/// </summary>
/// <param name="webhook">The reference webhook to notify</param>
/// <param name="httpClient">The HttpClient instance to use to send the notification</param>
/// <param name="kind">The Kind of webhook</param>
/// <param name="parser">The parser to use for parsing parameters, optional</param>
/// <param name="objectHandler">The objectHandler name, optional</param>
/// <param name="exception">The exception, optional</param>
/// <param name="scope">The PnP Provisioning Scope, if any, optional</param>
public static void InvokeWebhook(ProvisioningWebhookBase webhook,
HttpClient httpClient,
ProvisioningTemplateWebhookKind kind, TokenParser parser = null,
string objectHandler = null, Exception exception = null,
PnPMonitoredScope scope = null)
{
var requestParameters = new Dictionary <String, String>();
if (exception != null)
{
// For GET requests we limit the size of the exception to avoid issues
requestParameters["__exception"] =
webhook.Method == ProvisioningTemplateWebhookMethod.GET ?
exception.Message : exception.ToString();
}
SimpleTokenParser internalParser = new SimpleTokenParser();
if (webhook.Parameters != null)
{
foreach (var webhookparam in webhook.Parameters)
{
requestParameters.Add(webhookparam.Key, parser != null ? parser.ParseString(webhookparam.Value) : webhookparam.Value);
internalParser.AddToken(new WebhookParameter(webhookparam.Key, requestParameters[webhookparam.Key]));
}
}
var url = parser != null?parser.ParseString(webhook.Url) : webhook.Url; // parse for template scoped parameters
url = internalParser.ParseString(url); // parse for webhook scoped parameters
// Fix URL if it does not contain ?
if (!url.Contains("?"))
{
url += "?";
}
switch (webhook.Method)
{
case ProvisioningTemplateWebhookMethod.GET:
{
url += $"&__webhookKind={kind.ToString()}"; // add the webhook kind to the REST request URL
foreach (var k in requestParameters.Keys)
{
url += $"&{HttpUtility.UrlEncode(k)}={HttpUtility.UrlEncode(requestParameters[k])}";
}
if ((kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningStarted ||
kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningCompleted ||
kind == ProvisioningTemplateWebhookKind.ExceptionOccurred) && objectHandler != null)
{
url += $"&__handler={HttpUtility.UrlEncode(objectHandler)}"; // add the handler name to the REST request URL
}
try
{
if (webhook.Async)
{
Task.Factory.StartNew(async() =>
{
await httpClient.GetAsync(url);
});
}
else
{
httpClient.GetAsync(url).GetAwaiter().GetResult();
}
}
catch (HttpRequestException ex)
{
scope?.LogError(ex, "Error calling provisioning template webhook");
}
break;
}
case ProvisioningTemplateWebhookMethod.POST:
{
requestParameters.Add("__webhookKind", kind.ToString()); // add the webhook kind to the parameters of the request body
if ((kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningCompleted ||
kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningStarted ||
kind == ProvisioningTemplateWebhookKind.ExceptionOccurred) && objectHandler != null)
{
requestParameters.Add("__handler", objectHandler); // add the handler name to the parameters of the request body
}
try
{
if (webhook.Async)
{
Task.Factory.StartNew(async() =>
{
switch (webhook.BodyFormat)
{
case ProvisioningTemplateWebhookBodyFormat.Json:
using (var stringContent = new StringContent(JsonConvert.SerializeObject(requestParameters), Encoding.UTF8, "application/json"))
{
await httpClient.PostAsync(url, stringContent);
}
break;
case ProvisioningTemplateWebhookBodyFormat.Xml:
using (var stringContent = new StringContent(SerializeXml(requestParameters), Encoding.UTF8, "application/xml"))
{
await httpClient.PostAsync(url, stringContent);
}
break;
case ProvisioningTemplateWebhookBodyFormat.FormUrlEncoded:
using (var content = new FormUrlEncodedContent(requestParameters))
{
await httpClient.PostAsync(url, content);
}
break;
}
});
}
else
{
switch (webhook.BodyFormat)
{
case ProvisioningTemplateWebhookBodyFormat.Json:
using (var stringContent = new StringContent(JsonConvert.SerializeObject(requestParameters), Encoding.UTF8, "application/json"))
{
httpClient.PostAsync(url, stringContent).GetAwaiter().GetResult();
}
break;
case ProvisioningTemplateWebhookBodyFormat.Xml:
using (var stringContent = new StringContent(SerializeXml(requestParameters), Encoding.UTF8, "application/xml"))
{
httpClient.PostAsync(url, stringContent);
}
break;
case ProvisioningTemplateWebhookBodyFormat.FormUrlEncoded:
using (var content = new FormUrlEncodedContent(requestParameters))
{
httpClient.PostAsync(url, content).GetAwaiter().GetResult();
}
break;
}
}
}
catch (HttpRequestException ex)
{
scope?.LogError(ex, "Error calling provisioning template webhook");
}
break;
}
}
}
private static void AddProvisioningWebhook(ProvisioningHierarchy hierarchy,
Infrastructure.DomainModel.Provisioning.ProvisioningWebhook webhook, ProvisioningTemplateWebhookKind kind)
{
hierarchy.ProvisioningWebhooks.Add(new OfficeDevPnP.Core.Framework.Provisioning.Model.ProvisioningWebhook
{
Kind = kind,
Url = webhook.Url,
Method = (ProvisioningTemplateWebhookMethod)Enum.Parse(typeof(ProvisioningTemplateWebhookMethod), webhook.Method.ToString(), true),
BodyFormat = ProvisioningTemplateWebhookBodyFormat.Json, // force JSON format
Async = false, // force sync webhooks
Parameters = webhook.Parameters,
});
}
private static void AddProvisioningTemplateWebhook(ProvisioningTemplate template,
Infrastructure.DomainModel.Provisioning.ProvisioningWebhook webhook, ProvisioningTemplateWebhookKind kind)
{
template.ProvisioningTemplateWebhooks.Add(new ProvisioningTemplateWebhook
{
Kind = kind,
Url = webhook.Url,
Method = (ProvisioningTemplateWebhookMethod)Enum.Parse(typeof(ProvisioningTemplateWebhookMethod), webhook.Method.ToString(), true),
BodyFormat = ProvisioningTemplateWebhookBodyFormat.Json, // force JSON format
Async = true, // force sync webhooks
Parameters = webhook.Parameters,
});
}
private void CallWebHooks(ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateWebhookKind kind, String objectHandler = null, Exception exception = null)
{
if (template != null)
{
using (var scope = new PnPMonitoredScope("ProvisioningTemplate WebHook Call"))
{
var webhooks = new List <ProvisioningWebhookBase>();
// Merge the webhooks at template level with those at global level
if (template.ProvisioningTemplateWebhooks != null && template.ProvisioningTemplateWebhooks.Any())
{
webhooks.AddRange(template.ProvisioningTemplateWebhooks);
}
if (template.ParentHierarchy?.ProvisioningWebhooks != null && template.ParentHierarchy.ProvisioningWebhooks.Any())
{
webhooks.AddRange(template.ParentHierarchy.ProvisioningWebhooks);
}
// If there is any webhook
if (webhooks.Count > 0)
{
foreach (var webhook in webhooks.Where(w => w.Kind == kind))
{
var requestParameters = new Dictionary <String, String>();
if (exception != null)
{
// For GET requests we limit the size of the exception to avoid issues
requestParameters["__exception"] =
webhook.Method == ProvisioningTemplateWebhookMethod.GET ?
exception.Message : exception.ToString();
}
SimpleTokenParser internalParser = new SimpleTokenParser();
foreach (var webhookparam in webhook.Parameters)
{
requestParameters.Add(webhookparam.Key, parser.ParseString(webhookparam.Value));
internalParser.AddToken(new WebhookParameter(webhookparam.Key, requestParameters[webhookparam.Key]));
}
var url = parser.ParseString(webhook.Url); // parse for template scoped parameters
url = internalParser.ParseString(url); // parse for webhook scoped parameters
switch (webhook.Method)
{
case ProvisioningTemplateWebhookMethod.GET:
{
url += $"&__webhookKind={kind.ToString()}"; // add the webhook kind to the REST request URL
foreach (var k in requestParameters.Keys)
{
url += $"&{HttpUtility.UrlEncode(k)}={HttpUtility.UrlEncode(requestParameters[k])}";
}
if (kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningStarted ||
kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningCompleted ||
kind == ProvisioningTemplateWebhookKind.ExceptionOccurred)
{
url += $"&__handler={HttpUtility.UrlEncode(objectHandler)}"; // add the handler name to the REST request URL
}
try
{
if (webhook.Async)
{
Task.Factory.StartNew(async() =>
{
await httpClient.GetAsync(url);
});
}
else
{
httpClient.GetAsync(url).GetAwaiter().GetResult();
}
}
catch (HttpRequestException ex)
{
scope.LogError(ex, "Error calling provisioning template webhook");
}
break;
}
case ProvisioningTemplateWebhookMethod.POST:
{
requestParameters.Add("__webhookKind", kind.ToString()); // add the webhook kind to the parameters of the request body
if (kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningCompleted ||
kind == ProvisioningTemplateWebhookKind.ObjectHandlerProvisioningStarted ||
kind == ProvisioningTemplateWebhookKind.ExceptionOccurred)
{
requestParameters.Add("__handler", objectHandler); // add the handler name to the parameters of the request body
}
try
{
if (webhook.Async)
{
Task.Factory.StartNew(async() =>
{
switch (webhook.BodyFormat)
{
case ProvisioningTemplateWebhookBodyFormat.Json:
await httpClient.PostAsJsonAsync(url, requestParameters);
break;
case ProvisioningTemplateWebhookBodyFormat.Xml:
await httpClient.PostAsXmlAsync(url, requestParameters);
break;
case ProvisioningTemplateWebhookBodyFormat.FormUrlEncoded:
var content = new FormUrlEncodedContent(requestParameters);
await httpClient.PostAsync(url, content);
break;
}
});
}
else
{
switch (webhook.BodyFormat)
{
case ProvisioningTemplateWebhookBodyFormat.Json:
httpClient.PostAsJsonAsync(url, requestParameters).GetAwaiter().GetResult();
break;
case ProvisioningTemplateWebhookBodyFormat.Xml:
httpClient.PostAsXmlAsync(url, requestParameters).GetAwaiter().GetResult();
break;
case ProvisioningTemplateWebhookBodyFormat.FormUrlEncoded:
var content = new FormUrlEncodedContent(requestParameters);
httpClient.PostAsync(url, content).GetAwaiter().GetResult();
break;
}
}
}
catch (HttpRequestException ex)
{
scope.LogError(ex, "Error calling provisioning template webhook");
}
break;
}
}
}
}
}
}
}
