Beispiel #1
0
        private async Task <ActivityType?> CreateActivityTypeAsync(Type activityType, CancellationToken cancellationToken)
        {
            var info = await _describesActivityType.DescribeAsync(activityType, cancellationToken);

            return(new ActivityType
            {
                TypeName = info.Type,
                Type = activityType,
                Description = info.Description,
                DisplayName = info.DisplayName,
                ActivateAsync = async context => await ActivateActivity(context, activityType),
                DescribeAsync = async() => (await _describesActivityType.DescribeAsync(activityType, cancellationToken)) !,
                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> 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(Type activityType, CancellationToken cancellationToken)
        {
            var info = await _describesActivityType.DescribeAsync(activityType, cancellationToken);

            if (info == null)
            {
                return(default);
Beispiel #5
0
        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 async Task <ActivityType> CreateActivityTypeAsync(Type activityType, CancellationToken cancellationToken)
        {
            var info = await _describesActivityType.DescribeAsync(activityType, cancellationToken);

            return(new ActivityType
            {
                TypeName = info.Type,
                Type = activityType,
                Description = info.Description,
                DisplayName = info.DisplayName,
                IsBrowsable = activityType.GetCustomAttribute <BrowsableAttribute>(false)?.Browsable ?? true,
                ActivateAsync = async context => await ActivateActivity(context, activityType),
                DescribeAsync = async() => (await _describesActivityType.DescribeAsync(activityType, cancellationToken)) !,
                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> 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 <ActivityDescriptor> DescribeAsync <T>(this IDescribesActivityType type, CancellationToken cancellationToken = default) where T : IActivity => (await type.DescribeAsync(typeof(T), cancellationToken)) !;