How can I access SyntheticProperties from ExecuteAsync() method of my activity?

[sleepysimon89]

Hello together,

I build some activities on runtime using a custom ActivityProvider implementation. The necessary inputs are defined on runtime.

I get the values in the SyntheticProperties dictionary during execution of the activity and I can access them using the following code:

But this only works for literals. Is there any possibility to access it typesafe with expression evaluated?

Thanks in advance!

[glime-ai[bot]]

To access the values in a type-safe manner with expression evaluation, you can use the EvaluateAsync method provided by the IWorkflowExpressionEvaluator service. This service allows you to evaluate expressions against a given context, which can be an ActivityExecutionContext in your case.

Here's an example of how you might use it:

public class MyCustomActivity : Activity
{
    private readonly IWorkflowExpressionEvaluator _expressionEvaluator;

    public MyCustomActivity(IWorkflowExpressionEvaluator expressionEvaluator)
    {
        _expressionEvaluator = expressionEvaluator;
    }

    protected override async ValueTask<IActivityExecutionResult> OnExecuteAsync(ActivityExecutionContext context)
    {
        // Assuming you have a synthetic property called "MyExpressionProperty"
        var expression = context.GetInput<string>("MyExpressionProperty");
        var type = typeof(MyExpectedType); // Replace with the expected type of the result

        // Evaluate the expression
        var result = await _expressionEvaluator.EvaluateAsync(expression, type, context, context.CancellationToken);

        // Use the result
        var typedResult = (MyExpectedType)result; // Cast to the expected type

        // Continue with your activity logic...
    }
}

In this example, MyExpectedType should be replaced with the actual type you expect the result to be. The EvaluateAsync method will evaluate the expression and return the result as an object, which you can then cast to the expected type.

Please note that you will need to inject the IWorkflowExpressionEvaluator service into your custom activity to use it for evaluating expressions.

If you are using Elsa 2.0 or later, you might also consider using the SetVariable and GetVariable extension methods on the ActivityExecutionContext to work with variables in a type-safe manner.

Remember to handle any potential exceptions that might occur during expression evaluation, such as syntax errors or type mismatches.

If you need further assistance or if this approach does not fit your scenario, please provide more details about your custom ActivityProvider implementation and how you are defining and using the synthetic properties.

This comment was generated by Glime.

[jayachandra21]

Hello @sleepysimon89 ,

I do have a same scenario, where I have created a custom activity like as below:

public class GenerateReport : Activity
{
    [Input(
      UIHint = InputUIHints.DropDown,
      Description = "The File Type for the Generated Report.",
     Options = new[] { "PDF", "WORD", "EXCEL" })]
    public Input<string> ReportType { get; set; } = new("PDF");

    [Output(Description = "The Report File.")]
    public Output<byte[]> File { get; set; } = default!;

    protected override async ValueTask ExecuteAsync(ActivityExecutionContext context)
    {
        string reportType = context.Get(ReportType)!;
       //Logic goes here for the File.
        var file = context.Get(File)!;
        context.SetResult(file);
        await context.CompleteActivityAsync();
    }
}

---

I have created ActivityProvider class as below and registered with elsa services.
But when I add the activity in the workflow designer, i am unable to operate the designer and it got struckup.
Please check if MyActivityProvider is defined correctly.

public class MyActivityProvider : IActivityProvider
{
    private readonly IActivityFactory activityFactory;
    private readonly IActivityDescriber activityDescriber;
    private readonly IScopedServiceProvider<IReportRepository> reportServiceProvider;
    public MyActivityProvider(IActivityFactory activityFactory, IActivityDescriber activityDescriber, IScopedServiceProvider<IReportRepository> reportServiceProvider)
    {
        this.activityFactory = activityFactory;
        this.activityDescriber = activityDescriber;
        this.reportServiceProvider = reportServiceProvider;
    }
    public async ValueTask<IEnumerable<ActivityDescriptor>> GetDescriptorsAsync(CancellationToken cancellationToken = default)
    {
        var activityTypes = new List<ActivityDescriptor>();
        foreach (var report in reports)
        {
            //Logic to get parameters
            var activity = CreateReportActivity(report, parameters);
            activityTypes.Add(activity);
        }
        return activityTypes;
    }
    private ActivityDescriptor CreateReportActivity(Report report, List<ReportParameter> parameters, CancellationToken cancellationToken = default)
    {
        var activityTypeName = report.Id;
        var activityDisplayName = report.Name;

        return new ActivityDescriptor
        {
            TypeName = activityTypeName!,
            Name = report.Name,
            Category = "Reports,
            DisplayName = activityDisplayName!,
            Description = "Generate The Report in the Desired Format",
            Inputs = GenerateInputProperties(report, parameters),
            Kind = ActivityKind.Task,
            Outputs = new[] { new OutputDescriptor("File", "The Report File.", typeof(byte[]), null, null) }
        };
    }
    private ICollection<InputDescriptor> GenerateInputProperties(Report report, List<ReportParameter> parameters)
    {
        List<InputDescriptor> activityInputDescriptors = new List<InputDescriptor>();
        var order = 0;
        if (parameters != null)
        {
            var activityInput = new InputDescriptor
            {
                Name = nameof(GenerateReport.ReportType),
                Type = typeof(string),
                UIHint = InputUIHints.DropDown,
                Description = "The File Type for the Generated Report.",
                DisplayName = "Report Type",
                Category = "Parameters",
                Order = order++,
                DefaultValue = "PDF",
                IsSynthetic = true,
                IsWrapped = true,
                AutoEvaluate = false,
                StorageDriverType = typeof(WorkflowStorageDriver),
                ValueGetter = activity => activity.SyntheticProperties.GetValueOrDefault(nameof(GenerateReport.ReportType)),
                ValueSetter = (activity, value) => activity.SyntheticProperties[nameof(GenerateReport.ReportType)] = value!,
                IsSerializable = true
            };
            activityInputDescriptors.Add(activityInput);
        }
        return activityInputDescriptors.ToArray();
    }
}

[sleepysimon89]

For your case I do not understand why you implement an ActivityProvider.

You can simply add the activity by elsa.AddActivity<GenerateReport>();
All you need to do is to add the ActivityAttribute to your activity.

[jayachandra21]

We created an ActivityProvider to create a activity based on the Custom activity. My scenario is like this:

1. Create a custom activity with parameters.
2. In the Custom Activity, I have a input parameter with values.
3. with input value there should be separate activity created with output parameter of Custom Activity mentioned in point No.1

[jayachandra21]

For your case I do not understand why you implement an ActivityProvider.

You can simply add the activity by elsa.AddActivity<GenerateReport>(); All you need to do is to add the ActivityAttribute to your activity.

This is works for the Custom Activity. But in my case, I am generating an activities based on the parent activity Input parameter(Dropdown)