public async Task <ActionResult <WebhookDefinition> > Handle([FromBody] SaveWebhookDefinitionRequest request, [FromRoute] ApiVersion apiVersion, CancellationToken cancellationToken) { var webhookId = request.Id; var webhookDefinition = !string.IsNullOrWhiteSpace(webhookId) ? await _store.FindAsync(new EntityIdSpecification <WebhookDefinition>(webhookId), cancellationToken) : default; if (webhookDefinition == null) { webhookDefinition = new WebhookDefinition { Id = !string.IsNullOrWhiteSpace(webhookId) ? webhookId : _idGenerator.Generate(), } } ; webhookDefinition.Name = request.Name.Trim(); webhookDefinition.Path = request.Path.Trim(); webhookDefinition.Description = request.Description?.Trim(); webhookDefinition.PayloadTypeName = request.PayloadTypeName?.Trim(); webhookDefinition.IsEnabled = request.IsEnabled; await _store.SaveAsync(webhookDefinition, cancellationToken); return(CreatedAtAction("Handle", "Get", new { id = webhookDefinition.Id, apiVersion = apiVersion.ToString() }, webhookDefinition)); } }
public async Task AddAsync(WebhookDefinition entity, CancellationToken cancellationToken = default) { await _mediator.Publish(new WebhookDefinitionSaving(entity), cancellationToken); await _store.AddAsync(entity, cancellationToken); await _mediator.Publish(new WebhookDefinitionSaved(entity), cancellationToken); }
private WebhookDefinition Initialize(WebhookDefinition webhookDefinition) { if (string.IsNullOrWhiteSpace(webhookDefinition.Id)) { webhookDefinition.Id = _idGenerator.Generate(); } return(webhookDefinition); }
public WebhookDefinitionSurrogate(WebhookDefinition value) { Id = value.Id; TenantId = value.TenantId; Name = value.Name; Path = value.Path; Description = value.Description; PayloadTypeName = value.PayloadTypeName; }
private ActivityType CreateWebhookActivityType(WebhookDefinition webhook) { var activityTypeName = webhook.Name.EndsWith(WebhooksActivityTypeSuffix) ? webhook.Name : $"{webhook.Name}{WebhooksActivityTypeSuffix}"; var activityDisplayName = activityTypeName.Humanize(); var descriptor = new ActivityDescriptor { Type = activityTypeName, DisplayName = activityDisplayName, Category = WebhooksActivityCategory, Outcomes = new[] { OutcomeNames.Done }, Traits = ActivityTraits.Trigger, InputProperties = new[]
public async Task <bool> SaveAsync(WebhookDefinition model, bool?references = true, CancellationToken token = default) { var persisted = false; using (var scope = TransactionScopeOption.Required.AsTransactionScopeFlow()) { var result = await collection.ReplaceOneAsync(x => x.Id == model.Id, model, new ReplaceOptions { IsUpsert = true }); persisted = result.IsAcknowledged; scope.Complete(); } return(persisted); }
public bool Save(WebhookDefinition model, bool?references = true) { var inserted = false; using (var scope = TransactionScopeOption.Required.AsTransactionScope()) { using (var db = factory.OpenDbConnection()) { inserted = db.Save(model, references.Value); } scope.Complete(); } return(inserted); }
public async Task <bool> SaveAsync(WebhookDefinition model, bool?references = true, CancellationToken token = default) { var inserted = false; using (var scope = TransactionScopeOption.Required.AsTransactionScopeFlow()) { using (var db = factory.OpenDbConnection()) { inserted = await db.SaveAsync(model, references ?? false); } scope.Complete(); } return(inserted); }
public bool Save(WebhookDefinition model, bool?references = true) { var persisted = false; using (var scope = TransactionScopeOption.Required.AsTransactionScope()) { var result = collection.ReplaceOne(x => x.Id == model.Id, model, new ReplaceOptions { IsUpsert = true }); persisted = result.IsAcknowledged; scope.Complete(); } return(persisted); }
private ActivityType CreateWebhookActivityType(WebhookDefinition webhook) { var typeName = webhook.Name; var displayName = webhook.Name; var descriptor = new ActivityDescriptor { Type = typeName, DisplayName = displayName, Category = WebhookActivityCategory, Outcomes = new[] { OutcomeNames.Done }, Traits = ActivityTraits.Trigger, InputProperties = new[] { new ActivityInputDescriptor( nameof(HttpEndpoint.Methods), typeof(HashSet <string>), ActivityInputUIHints.Dropdown, "Request Method", "Specify what request method this webhook should handle. Leave empty to handle both GET and POST requests", new[] { "", "GET", "POST" }, "Webhooks", 0, "POST", SyntaxNames.Literal, new[] { SyntaxNames.JavaScript, SyntaxNames.Liquid }) } }; async ValueTask <IActivity> ActivateActivityAsync(ActivityExecutionContext context) { var activity = await _activityActivator.ActivateActivityAsync <HttpEndpoint>(context); activity.Path = webhook.Path; activity.ReadContent = true; activity.TargetType = webhook.PayloadTypeName is not null and not "" ? Type.GetType(webhook.PayloadTypeName) : throw new Exception($"Type {webhook.PayloadTypeName} not found"); return(activity); } return(new ActivityType { TypeName = webhook.Name, Type = typeof(HttpEndpoint), Description = webhook.Description is not null and not "" ? webhook.Description : $"A webhook at {webhook.Path}", DisplayName = webhook.Name, ActivateAsync = ActivateActivityAsync, Describe = () => descriptor });
private static bool ShouldSend(WebhookDefinition webhook, bool isUpdate, string?name) { if (webhook.SendAlways) { return(true); } if (isUpdate) { return(webhook.SendConfirm); } else { return(!string.IsNullOrWhiteSpace(name) && string.Equals(name, webhook.Name, StringComparison.Ordinal)); } }
public async Task PublishAsync(WebhookDefinition webhook, object data) { var webhookSubscriptions = await _webhookSubscriptionBusiness.GetByWebhookIdAsync(webhook.Id); if (webhookSubscriptions == null || (webhookSubscriptions != null && webhookSubscriptions.Count == 0)) { return; } var webhookEvent = await InsertWebhookEventAsync(webhook.Id, data); foreach (var webhookSubscription in webhookSubscriptions) { await _webhookSender.SendAsync(new WebhookSenderArgs { WebhookEventId = webhookEvent.Id, Data = webhookEvent.Data, WebhookName = webhook.Name, WebhookSubscriptionId = webhookSubscription.Id, Secret = webhookSubscription.Secret, WebhookUri = webhookSubscription.WebhookUri }); } }
public Task RestoreAsync(WebhookDefinition model, bool?references = null) { model.IsDeleted = false; return(SaveAsync(model, references)); }
public async Task AddAsync(WebhookDefinition entity, CancellationToken cancellationToken = default) { entity = Initialize(entity); await _store.AddAsync(entity, cancellationToken); }
public WebhookDefinitionSaving(WebhookDefinition webhookDefinition) : base(webhookDefinition) { }
public bool Erase(WebhookDefinition model) { return(EraseByKey(model.Id)); }
public Task DeleteAsync(WebhookDefinition entity, CancellationToken cancellationToken) => _store.DeleteAsync(entity, cancellationToken);
public void Trash(WebhookDefinition model, bool?references = null) { model.IsDeleted = true; Save(model, references); }
public async Task TrashAsync(WebhookDefinition model, bool?references = null) { model.IsDeleted = true; await SaveAsync(model, references); }
public Task TrashAsync(WebhookDefinition model, bool?references = null) { model.IsDeleted = true; return(SaveAsync(model, references ?? false)); }
public async Task UpdateAsync(WebhookDefinition entity, CancellationToken cancellationToken) { entity = Initialize(entity); await _store.UpdateAsync(entity, cancellationToken); }
public WebhookDefinitionDeleting(WebhookDefinition webhookDefinition) : base(webhookDefinition) { }
public WebhookDefinitionNotification(WebhookDefinition webhookDefinition) => WebhookDefinition = webhookDefinition;
public Task <bool> EraseAsync(WebhookDefinition model, CancellationToken token = default) { return(EraseByKeyAsync(model.Id, token)); }
public void Restore(WebhookDefinition model, bool?references = null) { model.IsDeleted = false; Save(model, references); }
public bool Erase(WebhookDefinition model) => EraseByKey(model.Id);