activity based on Webhooks not getting ActivateActivityAsync() called

[zman2000]

I am trying to create my custom HTTPEndpoint based on the Webhooks module.
I used Elsa 2.0.
In Elsa'a project "ElsaDashboard.Samples.AspNetCore.Monolith" found under the "elsa-core\src\samples\dashboard\aspnetcore\ElsaDashboard.Samples.AspNetCore.Monolith" folder, I added file named "MyEndpointActivityTypeProvider.cs" with the following contents:

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Elsa;
using Elsa.Activities.Http;
using Elsa.Activities.Webhooks.Models;
using Elsa.Activities.Webhooks.Options;
using Elsa.Activities.Webhooks.Persistence;
using Elsa.Activities.Webhooks.Persistence.Decorators;
using Elsa.Activities.Webhooks.Persistence.InMemory;
using Elsa.Design;
using Elsa.Expressions;
using Elsa.Metadata;
using Elsa.Persistence.Specifications;
using Elsa.Services;
using Elsa.Services.Models;
using ElsaDashboard.Samples.AspNetCore.Monolith.Activities.ActivityTypes;
using Microsoft.Extensions.DependencyInjection;

namespace Microsoft.Extensions.DependencyInjection
{
    public static class ElsaOptionsExtensions
    {
        public static ElsaOptionsBuilder AddMyEndpoint(
            this ElsaOptionsBuilder elsaOptions,
            Action<MyEndpointOptions>? configure = default)
        {
            var services = elsaOptions.Services;

            // Configure Webhooks.
            var options = new MyEndpointOptions();
            configure?.Invoke(options);

            // Services.
            services
                .AddScoped<IActivityTypeProvider, MyEndpointActivityTypeProvider>()
                .AddScoped(options.WebhookDefinitionStoreFactory);

            services.Decorate<IWebhookDefinitionStore, InitializingWebhookDefinitionStore>();

            return elsaOptions;
        }
    }
}

namespace ElsaDashboard.Samples.AspNetCore.Monolith.Activities.ActivityTypes
{
    public class MyEndpointOptions
    {
        public MyEndpointOptions()
        {
            WebhookDefinitionStoreFactory = provider => ActivatorUtilities.CreateInstance<InMemoryWebhookStore>(provider);
        }

        internal Func<IServiceProvider, IWebhookDefinitionStore> WebhookDefinitionStoreFactory { get; set; }

        public MyEndpointOptions UseWebhookDefinitionStore(Func<IServiceProvider, IWebhookDefinitionStore> factory)
        {
            WebhookDefinitionStoreFactory = factory;
            return this;
        }
    }


    public class MyEndpointActivityTypeProvider : IActivityTypeProvider
    {
        private const string MyEndpointActivityCategory = "HTTP";

        private readonly IWebhookDefinitionStore _webhookDefinitionStore;
        private readonly IActivityActivator _activityActivator;

        public MyEndpointActivityTypeProvider(
            IWebhookDefinitionStore webhookDefinitionStore,
            IActivityActivator activityActivator)
        {
            _webhookDefinitionStore = webhookDefinitionStore;
            _activityActivator = activityActivator;
        }

        public async ValueTask<IEnumerable<ActivityType>> GetActivityTypesAsync(CancellationToken cancellationToken = default)
        {
            
            WebhookDefinition webhook = new WebhookDefinition()
            {
                Id = "35711798-2510-44bd-9faf-406a708ad1a3",
                Name = "MyEndpoint",
                Path = "",
                Description = "",
                PayloadTypeName = "",
                TenantId = ""
            };
            await _webhookDefinitionStore.AddAsync(webhook, cancellationToken);
            
            var specification = Specification<WebhookDefinition>.Identity;
            var definitions = await _webhookDefinitionStore.FindManyAsync(specification, cancellationToken: cancellationToken);

            var activityTypes = new List<ActivityType>();
            foreach (var definition in definitions)
            {
                var activity = CreateMyEndpointActivityType(definition);
                activityTypes.Add(activity);
            }

            return activityTypes;
        }

        private ActivityType CreateMyEndpointActivityType(WebhookDefinition webhook)
        {
            var typeName = webhook.Name;
            var displayName = webhook.Name;

            var descriptor = new ActivityDescriptor
            {
                Type = typeName,
                DisplayName = displayName,
                Category = MyEndpointActivityCategory,
                Outcomes = new[] { OutcomeNames.Done },
                Traits = ActivityTraits.Trigger,
                Properties = new[]
                {
                    new ActivityPropertyDescriptor(
                        nameof(HttpEndpoint.Methods),
                        typeof(HashSet<string>),
                        ActivityPropertyUIHints.Dropdown,
                        "Request Method",
                        "Specify what request method this webhook should handle. Leave empty to handle both GET and POST requests",
                        new[] { "GET", "POST" },
                        "",
                        "GET",
                        SyntaxNames.Literal,
                        new[] { SyntaxNames.JavaScript, SyntaxNames.Liquid }),
                    new ActivityPropertyDescriptor(
                        nameof(HttpEndpoint.Path),
                        typeof(string),
                        ActivityPropertyUIHints.SingleLine,
                        "Path",
                        "Path",
                        "",
                        "",
                        "/za_test",
                        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,
                Describe = () => descriptor,
                ActivateAsync = ActivateActivityAsync
			};
        }
    }
}

In Startup.cs, I registered custom HTTPEndpoint with .AddMyEndpoint():

services
    .AddElsa(options => options
            .UseEntityFrameworkPersistence(ef => ef.UseSqlite())
            .AddConsoleActivities()
            .AddHttpActivities(elsaSection.GetSection("Server").Bind)
            .AddEmailActivities(elsaSection.GetSection("Smtp").Bind)
            .AddQuartzTemporalActivities()
            .AddJavaScriptActivities()
            .AddActivitiesFrom<Startup>()
            .AddWorkflowsFrom<Startup>()
            .AddMyEndpoint()
    );

However, my ActivateActivityAsync() is never called. Do I need to call anything else in the Startup.cs or am I missing some other implementation?

Thanks

[sfmskywalker]

Just to be clear, the custom activity is available for you to use with the designer and you actually created a workflow using it and then performed an HTTP request to your endpoint?

[sfmskywalker]

Make sure also to implement your own bookmark provider as explained here.

[zman2000]

Yes, this custom activity is available in the designer and I used it in my workflow and then did HTTP request to my endpoint.

Based on the #1247 and #1249, you are right, I am missing my own bookmark provider. Info from these two tickets are very useful and should definitely be documented.

Thanks for help