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")); }