private async Task <ActivityType> CreateActivityTypeAsync(TaskDefinition taskDefinition, CancellationToken cancellationToken) { var descriptor = await _describesActivityType.DescribeAsync <RunTask>(cancellationToken); descriptor.Type = taskDefinition.Name; descriptor.DisplayName = taskDefinition.DisplayName ?? taskDefinition.Name; descriptor.Description = taskDefinition.Description; descriptor.InputProperties = Array.Empty <ActivityInputDescriptor>(); descriptor.Outcomes = taskDefinition.Outcomes?.ToArray() ?? new[] { OutcomeNames.Done }; return(new ActivityType { Type = typeof(RunTask), TypeName = descriptor.Type, DisplayName = descriptor.DisplayName, Describe = () => descriptor, Description = descriptor.Description, ActivateAsync = async context => { var activity = await _activityActivator.ActivateActivityAsync <RunTask>(context, cancellationToken); activity.TaskName = taskDefinition.Name; return activity; }, CanExecuteAsync = async(context, instance) => await instance.CanExecuteAsync(context), ExecuteAsync = async(context, instance) => await instance.ExecuteAsync(context), ResumeAsync = async(context, instance) => await instance.ResumeAsync(context) }); }
private async Task <ActivityType> CreateWebhookActivityTypeAsync(Type payloadType, WebhookAttribute webhookAttribute, CancellationToken cancellationToken) { var descriptor = await _describesActivityType.DescribeAsync <Webhook>(cancellationToken); descriptor.Description = webhookAttribute.Description; descriptor.DisplayName = webhookAttribute.DisplayName; descriptor.Type = webhookAttribute.ActivityType; var outputProperties = descriptor.OutputProperties.Where(x => x.Name != nameof(Webhook.Output)).ToList(); outputProperties.Add(new ActivityOutputDescriptor(nameof(Webhook.Output), payloadType)); descriptor.OutputProperties = outputProperties.ToArray(); return(new ActivityType { Describe = () => descriptor, Description = descriptor.Description, DisplayName = descriptor.DisplayName, TypeName = descriptor.Type, Attributes = new Dictionary <string, object> { [NotificationAttribute] = true, [EventTypeAttribute] = webhookAttribute.EventType }, ActivateAsync = async context => await _activityActivator.ActivateActivityAsync <Webhook>(context, cancellationToken), CanExecuteAsync = (context, instance) => instance.CanExecuteAsync(context), ExecuteAsync = (context, instance) => instance.ExecuteAsync(context), ResumeAsync = (context, instance) => instance.ResumeAsync(context), }); }
private async Task <ActivityType> CreateActivityTypeAsync(CommandDefinition command, CancellationToken cancellationToken) { async ValueTask <ActivityDescriptor> CreateDescriptorAsync() { var des = await _describesActivityType.DescribeAsync <SendCommand>(cancellationToken); des.Type = command.Name; des.DisplayName = command.DisplayName ?? command.Name; des.Description = command.Description; des.InputProperties = des.InputProperties.Where(x => x.Name != nameof(SendCommand.CommandName)).ToArray(); return(des); } var descriptor = await CreateDescriptorAsync(); return(new ActivityType { Type = typeof(SendCommand), TypeName = descriptor.Type, DisplayName = descriptor.DisplayName, DescribeAsync = CreateDescriptorAsync, Description = descriptor.Description, ActivateAsync = async context => { var activity = await _activityActivator.ActivateActivityAsync <SendCommand>(context, cancellationToken); activity.CommandName = command.Name; return activity; }, CanExecuteAsync = async(context, instance) => await instance.CanExecuteAsync(context), ExecuteAsync = async(context, instance) => await instance.ExecuteAsync(context), ResumeAsync = async(context, instance) => await instance.ResumeAsync(context) }); }
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 async Task <ActivityType> CreateActivityTypeAsync(EventDefinition eventDefinition, CancellationToken cancellationToken) { async ValueTask <ActivityDescriptor> CreateDescriptorAsync() { var des = await _describesActivityType.DescribeAsync <EventReceived>(cancellationToken); des.Type = eventDefinition.Name; des.DisplayName = eventDefinition.DisplayName ?? eventDefinition.Name; des.Description = eventDefinition.Description; des.InputProperties = Array.Empty <ActivityInputDescriptor>(); des.Outcomes = eventDefinition.Outcomes?.ToArray() ?? new[] { OutcomeNames.Done }; return(des); } var descriptor = await CreateDescriptorAsync(); return(new ActivityType { Type = typeof(EventReceived), TypeName = descriptor.Type, DisplayName = descriptor.DisplayName, DescribeAsync = CreateDescriptorAsync, Description = descriptor.Description, ActivateAsync = async context => { var activity = await _activityActivator.ActivateActivityAsync <EventReceived>(context, cancellationToken); activity.EventName = eventDefinition.Name; return activity; }, CanExecuteAsync = async(context, instance) => await instance.CanExecuteAsync(context), ExecuteAsync = async(context, instance) => await instance.ExecuteAsync(context), ResumeAsync = async(context, instance) => await instance.ResumeAsync(context) }); }
public static async Task <T> ActivateActivityAsync <T>(this IActivityActivator activityActivator, ActivityExecutionContext context, CancellationToken cancellationToken = default) where T : IActivity => (T)await activityActivator.ActivateActivityAsync(context, typeof(T), cancellationToken);