public void GetListWebhookSubscriptionsTest()
{
using (var scope = new PSTestScope(true))
{
using (var ctx = TestCommon.CreateClientContext())
{
// Create the test list
List testList = EnsureFreshTestList(ctx);
// Add a Webhook subscription
WebhookSubscription subscription = testList.AddWebhookSubscription(TestCommon.WebHookTestUrl);
// Add a second Webhook subscription
WebhookSubscription subscription2 = testList.AddWebhookSubscription(TestCommon.WebHookTestUrl);
// Test the Get-PnPWebhookSubscriptions cmdlet on the list
var output = scope.ExecuteCommand("Get-PnPWebhookSubscriptions",
new CommandParameter("List", PnPWebhookTestList));
Assert.IsTrue(output.All(o => typeof(IList <WebhookSubscription>).IsAssignableFrom(o.BaseObject.GetType())));
// Delete the test list
testList.DeleteObject();
ctx.ExecuteQueryRetry();
}
}
}
public void WhenSearchForDeliveryResults_ThenReturnsMatchingResultsInOrder()
{
var subscription = new WebhookSubscription();
var subscriptionId = store.Add(subscription);
var datum1 = SystemTime.UtcNow.ToNearestSecond();
var datum2 = datum1.AddDays(1);
var result1 = new SubscriptionDeliveryResult
{
Id = "aresultid1",
SubscriptionId = subscriptionId,
AttemptedDateUtc = datum1
};
var result2 = new SubscriptionDeliveryResult
{
Id = "aresultid2",
SubscriptionId = subscriptionId,
AttemptedDateUtc = datum2
};
store.Add(subscriptionId, result1);
store.Add(subscriptionId, result2);
var results = store.Search(subscriptionId, 1);
Assert.That(results.Count, Is.EqualTo(1));
Assert.That(results[0].Id, Is.EqualTo("aresultid2"));
}
public void RemoveListWebhookSubscriptionTest()
{
using (var scope = new PSTestScope(true))
{
using (var ctx = TestCommon.CreateClientContext())
{
// Create the test list
List testList = EnsureFreshTestList(ctx);
// Add a Webhook subscription
WebhookSubscription subscription = testList.AddWebhookSubscription(TestCommon.WebHookTestUrl);
// Test the Remove-PnPWebhookSubscription cmdlet on the list
scope.ExecuteCommand("Remove-PnPWebhookSubscription",
new CommandParameter("List", PnPWebhookTestList),
new CommandParameter("Identity", subscription.Id));
IList <WebhookSubscription> webhookSubscriptions = testList.GetWebhookSubscriptions();
Assert.IsTrue(webhookSubscriptions.Count() == 0);
// Delete the test list
testList.DeleteObject();
ctx.ExecuteQueryRetry();
}
}
}
public async Task Webhook_CreateAndDelete()
{
var client = await GetTestClientAsync();
var subscriptions = await client.Webhook.GetSubscriptionsAsync();
const string endpoint = "https://abc123mortgage.com";
var existingSubscription = subscriptions.FirstOrDefault(s => s.Endpoint == endpoint);
if (existingSubscription != null)
{
await client.Webhook.DeleteSubscriptionAsync(existingSubscription.SubscriptionId);
}
var subscription = new WebhookSubscription(endpoint, WebhookResourceType.Loan, new[] { WebhookResourceEvent.Change });
subscription.Filters.Attributes.Add("/milestoneLogs/*/doneIndicator");
var subscriptionId = await client.Webhook.CreateSubscriptionAsync(subscription);
Assert.IsFalse(string.IsNullOrEmpty(subscriptionId));
try
{
var retrievedSubscription = await client.Webhook.GetSubscriptionAsync(subscriptionId);
Assert.AreEqual(subscription.Endpoint, retrievedSubscription.Endpoint);
Assert.AreEqual(subscription.Resource.Value, retrievedSubscription.Resource.Value);
CollectionAssert.AreEquivalent(subscription.Events.Select(e => e.Value).ToList(), retrievedSubscription.Events.Select(e => e.Value).ToList());
CollectionAssert.AreEquivalent(subscription.Filters.Attributes.ToList(), retrievedSubscription.Filters.Attributes.ToList());
}
finally
{
await client.Webhook.DeleteSubscriptionAsync(subscriptionId);
}
}
public async Task <IActionResult> SubscribeWebhook(WebhookSubscriptionRequest request)
{
if (!ModelState.IsValid)
{
return(ValidationProblem(ModelState));
}
var userId = _identityService.GetUserIdentity();
// var grantOk = await _grantUrlTester.TestGrantUrl(request.Url, request.GrantUrl, request.Token ?? string.Empty);
// if (grantOk)
// {
var subscription = new WebhookSubscription
{
Date = DateTime.UtcNow,
DestUrl = request.Url,
Token = request.Token,
Type = Enum.Parse <WebhookType>(request.Event, true),
UserId = _identityService.GetUserIdentity()
};
_dbContext.Add(subscription);
await _dbContext.SaveChangesAsync();
return(CreatedAtAction("GetByUserAndId", new { id = subscription.Id }, subscription));
}
public void WhenSearchAndIsActive_ThenReturnsActiveSubscriptionsOnly()
{
var config1 = new SubscriptionConfig();
var config2 = new SubscriptionConfig();
var subscription1 = new WebhookSubscription
{
Event = "aneventname",
Config = config1,
IsActive = false
};
var subscription2 = new WebhookSubscription
{
Event = "aneventname",
Config = config2,
IsActive = true
};
cacheClient.As <ICacheClientExtended>().Setup(cc => cc.GetKeysByPattern(It.IsAny <string>()))
.Returns(new List <string> {
"akey1", "akey2"
});
cacheClient.Setup(cc => cc.Get <object>("akey1"))
.Returns(subscription1);
cacheClient.Setup(cc => cc.Get <object>("akey2"))
.Returns(subscription2);
var result = store.Search("aneventname", true);
Assert.That(result[0].Config, Is.EqualTo(config2));
cacheClient.As <ICacheClientExtended>().Verify(cc => cc.GetKeysByPattern(CacheClientSubscriptionStore.CachekeyPrefix + "*"));
cacheClient.Verify(cc => cc.Get <object>("akey1"));
cacheClient.Verify(cc => cc.Get <object>("akey2"));
}
public void WhenToEntity_ThenReturnsEntity()
{
var datum = DateTime.UtcNow;
var config = new SubscriptionConfig
{
Url = "aurl"
};
var result = new WebhookSubscription
{
Id = "asubscriptionid",
Config = config,
IsActive = true,
CreatedById = "auserid",
CreatedDateUtc = datum,
Event = "anevent",
Name = "aname",
LastModifiedDateUtc = datum
}.ToEntity();
Assert.That(result.RowKey, Is.EqualTo("asubscriptionid"));
Assert.That(result.PartitionKey, Is.EqualTo(string.Empty));
Assert.That(result.Id, Is.EqualTo("asubscriptionid"));
Assert.That(result.Config, Is.EqualTo(config.ToJson()));
Assert.That(result.IsActive, Is.EqualTo(true.ToString().ToLowerInvariant()));
Assert.That(result.CreatedById, Is.EqualTo("auserid"));
Assert.That(result.CreatedDateUtc, Is.EqualTo(datum));
Assert.That(result.Event, Is.EqualTo("anevent"));
Assert.That(result.Event, Is.EqualTo("anevent"));
Assert.That(result.Name, Is.EqualTo("aname"));
Assert.That(result.LastModifiedDateUtc, Is.EqualTo(datum));
}
public void AddWebhookWithVeryLastValidExpirationDateTest()
{
using (var clientContext = TestCommon.CreateClientContext())
{
var testList = clientContext.Web.Lists.GetById(webHookListId);
clientContext.Load(testList);
clientContext.ExecuteQueryRetry();
DateTime veryLastValidExpiration = DateTime.UtcNow.AddDays(180);
WebhookSubscription expectedSubscription = new WebhookSubscription()
{
ExpirationDateTime = veryLastValidExpiration,
NotificationUrl = TestCommon.TestWebhookUrl,
Resource = TestCommon.DevSiteUrl + string.Format("/_api/lists('{0}')", webHookListId)
};
WebhookSubscription actualSubscription = testList.AddWebhookSubscription(TestCommon.TestWebhookUrl, veryLastValidExpiration);
// Compare properties of expected and actual
Assert.IsTrue(Equals(expectedSubscription.ClientState, actualSubscription.ClientState) &&
Equals(expectedSubscription.ExpirationDateTime.Date, actualSubscription.ExpirationDateTime.Date) &&
Equals(expectedSubscription.NotificationUrl, actualSubscription.NotificationUrl) &&
expectedSubscription.Resource.Contains(actualSubscription.Resource));
}
}
public async Task <WebhookSubscription> DeleteSubscription(WebhookSubscription model)
{
_context.WebhookSubscriptions.Remove(model);
var result = await _context.SaveChangesAsync();
return(result > 0 ? model : null);
}
public void SetListWebhookSubscriptionTest()
{
using (var scope = new PSTestScope(true))
{
using (var ctx = TestCommon.CreateClientContext())
{
// Create the test list
List testList = EnsureFreshTestList(ctx);
// Add a Webhook subscription
WebhookSubscription subscription = testList.AddWebhookSubscription(TestCommon.WebHookTestUrl, DateTime.Today.AddDays(5));
// Change the expiration date
DateTime newExpirationDate = DateTime.Today.AddDays(20).ToUniversalTime();
subscription.ExpirationDateTime = newExpirationDate;
// Test the Set-PnPWebhookSubscription cmdlet on the list
scope.ExecuteCommand("Set-PnPWebhookSubscription",
new CommandParameter("List", PnPWebhookTestList),
new CommandParameter("Subscription", subscription));
// Get the subscription from the test list
var subscriptions = testList.GetWebhookSubscriptions();
Assert.IsTrue(subscriptions.Count == 1 && subscriptions[0].ExpirationDateTime == newExpirationDate);
// Delete the test list
testList.DeleteObject();
ctx.ExecuteQueryRetry();
}
}
}
public async Task <WebhookSubscription> CreateSubscription(WebhookSubscription model)
{
await _context.WebhookSubscriptions.AddAsync(model);
var result = await _context.SaveChangesAsync();
return(result > 0 ? model : null);
}
public WebhookSubscriptionPipeBind(string subscriptionId)
{
_subscriptionId = Guid.Parse(subscriptionId);
_subscription = new WebhookSubscription()
{
Id = subscriptionId
};
}
public WebhookSubscriptionPipeBind(Guid subscriptionId)
{
_subscriptionId = subscriptionId;
_subscription = new WebhookSubscription()
{
Id = subscriptionId.ToString()
};
}
public WebhookSubscriptionPipeBind()
{
_subscriptionId = Guid.Empty;
_subscription = new WebhookSubscription()
{
Id = _subscriptionId.ToString()
};
}
private static void AssertSubscriptionCreated(WebhookSubscription subscription, string eventName, string userId)
{
Assert.That(eventName, Is.EqualTo(subscription.Event));
Assert.That(subscription.CreatedById, Is.EqualTo(userId));
Assert.That(DateTime.UtcNow, Is.EqualTo(subscription.CreatedDateUtc).Within(5).Seconds);
Assert.That(DateTime.UtcNow, Is.EqualTo(subscription.LastModifiedDateUtc).Within(5).Seconds);
Assert.That(subscription.Id.HasValue());
}
/// <summary>
/// checks if subscribed to given webhook
/// </summary>
/// <returns></returns>
public static bool IsSubscribed(this WebhookSubscription webhookSubscription, string webhookName)
{
if (webhookSubscription.Webhooks.IsNullOrEmpty())
{
return(false);
}
return(webhookSubscription.Webhooks.Contains(webhookName));
}
public void WebhookSubscription_Serialization()
{
var subscription = new WebhookSubscription("https://google.com", WebhookResourceType.Loan, new[] { WebhookResourceEvent.Create, WebhookResourceEvent.Update })
{
ClientId = "1234567890"
};
Assert.AreEqual(@"{""events"":[""create"",""update""],""endpoint"":""https://google.com"",""resource"":""Loan""}", subscription.ToString(SerializationOptions.Dirty));
}
/// <summary>
/// Creates a WebhookSubscription
/// </summary>
/// <example>
/// {
/// "SubscriptionContext": {
/// "ResourceType": "Folder",
/// "ResourceId": "fo123"
/// },
/// "WebhookUrl": "https://webhook.com",
/// "Events":
/// [
/// { "ResourceType":"File", "OperationName":"Upload" },
/// { "ResourceType":"File", "OperationName":"Update" },
/// { "ResourceType":"File", "OperationName":"Download" },
/// { "ResourceType":"File", "OperationName":"Delete" },
/// ]
/// }
/// </example>
/// <remarks>
/// The above example subscribes `https://webhook.com` endpoint to be called when a File Upload, Update, Download or Delete
/// event happened for folder `fo123`.
/// Note: Context Resource Id is required for all but the account context.
/// The MasterAdmin role is required to create account context subscriptions.
/// </remarks>
/// <returns>
/// WebhookSubscription
/// </returns>
public IQuery <WebhookSubscription> Create(WebhookSubscription subscription)
{
var sfApiQuery = new ShareFile.Api.Client.Requests.Query <WebhookSubscription>(Client);
sfApiQuery.From("WebhookSubscriptions");
sfApiQuery.Body = subscription;
sfApiQuery.HttpMethod = "POST";
return(sfApiQuery);
}
/// <summary>
/// Posts the message to the discord webhook
/// </summary>
/// <param name="sub">The webhook subscription to use</param>
/// <param name="body">Full post body object</param>
/// <returns></returns>
public static async Task <bool> SendBodyAsync(WebhookSubscription sub, DiscordWebhookBody body)
{
using var http = new HttpClient();
var jsondata = JsonConvert.SerializeObject(body);
var res = await http.PostAsync($"https://discordapp.com/api/webhooks/{sub.WebhookId}/{sub.Token}", new StringContent(jsondata, Encoding.UTF8, "application/json")).ConfigureAwait(false);
var cont = await res.Content.ReadAsStringAsync();
return(res.IsSuccessStatusCode);
}
public void Update(string subscriptionId, WebhookSubscription subscription)
{
Guard.AgainstNullOrEmpty(() => subscriptionId, subscriptionId);
Guard.AgainstNull(() => subscription, subscription);
using (var db = dbFactory.Open())
{
db.Update(subscription);
}
}
public void WhenToEntityWithMinDates_ThenReturnsEntity()
{
var result = new WebhookSubscription
{
CreatedDateUtc = DateTime.MinValue,
LastModifiedDateUtc = DateTime.MinValue
}.ToEntity();
Assert.That(result.CreatedDateUtc, Is.EqualTo(Azure.Table.DateTimeExtensions.MinAzureDateTime));
Assert.That(result.LastModifiedDateUtc, Is.EqualTo(Azure.Table.DateTimeExtensions.MinAzureDateTime));
}
public async Task UpdateSubscription(WebhookSubscription subscription)
{
if (subscription.Id == default)
{
throw new ArgumentNullException(nameof(subscription.Id));
}
subscription.TenantId = AbpSession.TenantId;
await _webHookSubscriptionManager.AddOrUpdateSubscriptionAsync(subscription);
}
public string Add(WebhookSubscription subscription)
{
Guard.AgainstNull(() => subscription, subscription);
var id = DataFormats.CreateEntityIdentifier();
subscription.Id = id;
subscriptions.TryAdd(id, subscription);
return(id);
}
public void Update(string subscriptionId, WebhookSubscription subscription)
{
Guard.AgainstNullOrEmpty(() => subscriptionId, subscriptionId);
Guard.AgainstNull(() => subscription, subscription);
var existing = Get(subscriptionId);
if (existing != null)
{
subscriptions[subscriptionId] = subscription;
}
}
public async Task <IActionResult> Subscribe(WebhookSubscription model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
model.OwnerId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
var result = await _repository.CreateSubscription(model);
return(CreatedAtAction(nameof(Subscribe), result));
}
public void WhenAdd_ThenAddsToStorage()
{
var subscription = new WebhookSubscription();
var result = store.Add(subscription);
Assert.That(result.IsEntityId());
Assert.That(subscription.Id.IsEntityId());
Assert.That(subscription.Id, Is.EqualTo(result));
subscriptionStorage.Verify(ts => ts.Add(It.Is <WebhookSubscriptionEntity>(wse =>
wse.Id == result)));
}
public void WebhookSubscription_Serialization()
{
var subscription = new WebhookSubscription("https://google.com");
Assert.AreEqual(@"{""endpoint"":""https://google.com""}", subscription.ToJson());
subscription.Dirty = false;
Assert.AreEqual(@"{""endpoint"":""https://google.com""}", subscription.ToJson());
subscription.ClientId = "1234567890";
subscription.Events = new StringEnumValue <WebhookResourceEvent>[] { "add", "update", "remove" };
Assert.AreEqual(@"{""endpoint"":""https://google.com"",""clientId"":""1234567890"",""events"":[""add"",""update"",""remove""]}", subscription.ToJson());
subscription.Dirty = false;
Assert.AreEqual(@"{""endpoint"":""https://google.com""}", subscription.ToJson());
}
public void Update(string subscriptionId, WebhookSubscription subscription)
{
Guard.AgainstNullOrEmpty(() => subscriptionId, subscriptionId);
Guard.AgainstNull(() => subscription, subscription);
var persistedSubscription = GetSubscription(subscriptionId);
if (persistedSubscription.Value != null)
{
var key = persistedSubscription.Key;
CacheClient.Set(key, subscription);
}
}
public void WhenAddSubscription_ThenReturnsId()
{
var subscription = new WebhookSubscription
{
Event = "aneventname",
CreatedById = "auserid"
};
var result = store.Add(subscription);
Assert.That(result.IsEntityId(), Is.True);
cacheClient.Verify(cc => cc.Add(CacheClientSubscriptionStore.FormatCacheKey("auserid", "aneventname"), It.Is <WebhookSubscription>(sub
=> sub.Id.IsEntityId())));
}
public void WhenFind_ThenReturnsSubscriptions()
{
var subscription = new WebhookSubscription();
cacheClient.Setup(cc => cc.Get <object>("akey"))
.Returns(subscription);
var result = store.Find("auserid");
Assert.That(result[0], Is.EqualTo(subscription));
cacheClient.As <ICacheClientExtended>().Verify(cc => cc.GetKeysByPattern(CacheClientSubscriptionStore.FormatCacheKey("auserid", null) + "*"));
cacheClient.Verify(cc => cc.Get <object>("akey"));
}
