Aurora.Workflows.Tasks.Selenium 0.5.1.23

Aurora Workflows

Visual workflow automation for .NET. Compose workflows in a visual designer or with a C# Fluent API, use real C# expressions (Roslyn) for dynamic values, extend the engine with your own task packages, and run workflows headless – in your own process, from a CLI or on a distributed hosting node.

Project website & documentation: https://aurora.unex.me/workflows

What you get

• Visual designer – drag & drop tasks, wire inputs/outputs, edit expressions, run and debug. Workflows are saved as .awf and published as self-contained .awfc packages.
• C# expressions – any string task property can be plain text or a C# expression prefixed with = (=Path.Combine(inputDir, fileName)). Workflow variables are available as typed locals inside expressions.
• Fluent API – build the same workflows in code, run them directly or persist them for the designer.
• Explicit task contracts – tasks declare inputs and outputs; data flows Input -> Task -> Output instead of through hidden side effects.
• Extensible – 70+ built-in tasks (control flow, files, HTTP, scripting, mail, JSON, …) plus domain packages (SQL/Data, Windows, IT-Ops, Selenium, Media). Custom tasks are ordinary .NET classes.
• Headless runtime & hosting – execute workflows without the designer, or publish them to the hosting database for scheduled, distributed execution.

Packages

dotnet add package Aurora.Workflows            # core engine (designer-independent)
dotnet add package Aurora.Workflows.Tasks      # built-in tasks
dotnet add package Aurora.Workflows.Fluent     # Fluent API
dotnet add package Aurora.Workflows.Extensions # load/run published .awfc packages, NuGet resolver, host builder
dotnet add package Aurora.Workflows.Contracts  # contracts/attributes (netstandard2.0)
dotnet add package Aurora.Workflows.UI.Host    # visual designer; F5-debug custom task libraries

Fluent API example

Workflow format v2 rule: plain strings are literals; a value prefixed with = is evaluated as a C# expression. Fluent methods that take an expression (Set, If, Loop, PrintExpression, ReadFileExpression, …) add the marker for you; SetValue, Print, ReadFile, WriteFile store literal text. Workflow variables are referenced by name inside expressions.

using Aurora.Workflows.Fluent;
using Aurora.Workflows.Tasks;

var workflow = FluentWorkflow
    .Create("Nightly Import")
    .TriggerOnSchedule("0 0 2 * * ?")                       // Quartz cron: 02:00 every day
    .SetValue("inputDir", @"C:\data\in")                    // literal text -> variable "inputDir"
    .Set("stamp", "DateTime.Now.ToString(\"yyyyMMdd\")")    // C# expression -> variable "stamp"
    .Do<GetFileListTask>(t => { t.Expression = "=inputDir"; t.Pattern = "*.csv"; })
        .WithOutput("files")                                // task output -> variable "files"
    .If("files.Length == 0",
        then: t => t.Print("Nothing to import."),
        @else: t => t
            .Do<CountCsvRowsTask>()                         // custom task, see below
                .WithInput("files")
                .WithOutput("rowCount")
            .PrintExpression("$\"Imported {rowCount} rows from {files.Length} files ({stamp})\""))
    .Build();

await workflow.StartAsync();

Persist a fluent workflow as JSON and reload it later – or open it in the visual designer:

string json = FluentWorkflow.Create("Persisted").TriggerOnce().Print("ready").Commit().Persist();
var restored = FluentWorkflow.Load(json).Build();

Writing a custom task

A task derives from WorkflowTaskBase (or ExpressionWorkflowTaskBase if it has one primary expression property), declares its inputs and outputs with attributes, reads inputs with GetInput<T>() and publishes results with SetOutput(). Because every string property can be plain text or a = expression (the user decides in the designer), string properties are read through Resolve<T>() rather than used directly.

using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Aurora.Workflows.Contracts;
using Aurora.Workflows.Contracts.Attributes;
using Aurora.Workflows.Tasks;

[WorkflowTaskCategory("Import")]
[WorkflowTaskInputDefinition(typeof(FileInfo[]), IsDefault = true, IsRequired = true,
    Description = "CSV files to inspect.")]
[WorkflowTaskOutputDefinition(typeof(int), IsDefault = true,
    Description = "Total number of data rows across all files.")]
[Description("Counts the data rows of CSV files.")]
public sealed class CountCsvRowsTask : WorkflowTaskBase
{
    // Expression-capable: "true" (plain text) or "=files.Length > 1" (evaluated at runtime)
    [Description("Whether the first line of each file is a header. Plain text or '=' expression.")]
    public string HasHeader { get; set; } = "true";

    public CountCsvRowsTask() { Name = "Count CSV Rows"; }

    protected override Task<bool> DoAsync(IWorkflowDataContext context)
    {
        var files = GetInput<FileInfo[]>(context);            // declared input
        var hasHeader = Resolve<bool>(HasHeader, context);   // text or evaluated expression

        var rows = files.Sum(f => File.ReadLines(f.FullName).Count() - (hasHeader ? 1 : 0));

        SetOutput(context, rows);                            // declared output
        return Task.FromResult(true);
    }

    protected override Task<bool> DoSetupAsync() => Task.FromResult(true);    // before first run
    protected override Task<bool> DoTearDownAsync() => Task.FromResult(true); // on workflow stop
}

Tasks in a referenced assembly are discovered by the designer's toolbox and by hosts that load the package. Scope tasks with children (loops, conditionals) derive from TransactionScopeTaskBase.

Tip: developing custom tasks in a class library? Add a reference to Aurora.Workflows.UI.Host – its build props set the start program so pressing F5 opens the visual designer with your project loaded for interactive debugging.

Headless execution

Run a published .awfc package from your own .NET process (Aurora.Workflows.Extensions):

using Aurora.Workflows;
using Aurora.Workflows.Extensions.Services;

using var managed = new ManagedWorkflow(loggerFactory, new DotNetAssemblyLoaderProxyService(loggerFactory));
managed.Load(File.ReadAllBytes(@"C:\workflows\nightly-import.awfc"), restoreNugetPackages: true);

var context = WorkflowDataContext.Create(managed.GetWorkflow());
context["inputDir"] = @"D:\drop";                           // global workflow variable, e.g. from CLI args

await managed.StartAsync(context);

Or use the CLI runner: Aurora.Workflows.Cli.exe --inputDir="D:\drop" executes the .awfc files in its workflows/ folder. See the documentation for the compiler, runner and workflow hosting: https://aurora.unex.me/workflows/docs/

License

Aurora Workflows is free to use in full for non-commercial projects. For commercial use, please get in touch to discuss licensing terms; redistribution, modification, decompilation, reverse-engineering, or publication of the software without explicit written permission is strictly prohibited.