/// <summary>
/// Declares a teardown action (related to this step and/or previous steps) which will be executed
/// after all steps in the current scenario have been executed.
/// </summary>
/// <param name="stepDefinition">The step definition.</param>
/// <param name="action">The action.</param>
/// <returns>
/// An instance of <see cref="IStepDefinition"/>.
/// </returns>
public static IStepDefinition Teardown(this IStepDefinition stepDefinition, Action <IStepContext> action)
{
IStepBuilder stepBuilder = stepDefinition;
stepBuilder.Teardown(action);
return(stepDefinition);
}
public ParallelStepBuilder(IWorkflowBuilder<TData> workflowBuilder, IStepBuilder<TData, TStepBody> stepBuilder, IStepBuilder<TData, Sequence> referenceBuilder)
{
WorkflowBuilder = workflowBuilder;
Step = stepBuilder.Step;
_stepBuilder = stepBuilder;
_referenceBuilder = referenceBuilder;
}
/// <summary>
/// Declares a teardown action (related to this step and/or previous steps) which will be executed
/// after all steps in the current scenario have been executed.
/// </summary>
/// <param name="stepDefinition">The step definition.</param>
/// <param name="action">The action.</param>
/// <returns>
/// An instance of <see cref="IStepDefinition"/>.
/// </returns>
public static IStepDefinition Teardown(this IStepDefinition stepDefinition, Func <Task> action)
{
IStepBuilder stepBuilder = stepDefinition;
stepBuilder.Teardown(action);
return(stepDefinition);
}
public IStepBuilder <TData, TStep> Then <TStep>(IStepBuilder <TData, TStep> step)
where TStep : IStepBody
{
Outcome.NextStep = step.Step.Id;
var stepBuilder = new StepBuilder <TData, TStep>(WorkflowBuilder, step.Step);
return(stepBuilder);
}
internal static IStepBuilder <TData, RenderOverlay> RenderOverlay <TStep, TData>(
this IStepBuilder <TData, TStep> builder, Expression <Func <TData, Image <Rgba32>?> >?image)
where TStep : IStepBody
where TData : WorkflowData
=> builder
.Then <TStep, RenderOverlay, TData>("Render overlay")
.Input(step => step.SourceImage, image)
.Output(data => data.OverlayImage, step => step.OverlayImage);
/// <summary>
/// Declares a rollback action, relating to this step or previous steps, which will be
/// executed after all steps in the current scenario have been executed.
/// </summary>
/// <param name="stepBuilder">The step builder.</param>
/// <param name="onRollback">The rollback callback.</param>
/// <returns>
/// An instance of <see cref="IStepBuilder"/>.
/// </returns>
public static IStepBuilder Rollback(this IStepBuilder stepBuilder, Action <IStepContext> onRollback) =>
onRollback == null
? stepBuilder
: stepBuilder?.Rollback(context =>
{
onRollback(context);
return(Task.FromResult(0));
});
/// <summary>
/// Declares a teardown action (related to this step and/or previous steps) which will be executed
/// after all steps in the current scenario have been executed.
/// </summary>
/// <param name="stepBuilder">The step builder.</param>
/// <param name="action">The action.</param>
/// <returns>
/// An instance of <see cref="IStepBuilder"/>.
/// </returns>
public static IStepBuilder Teardown(this IStepBuilder stepBuilder, Action <IStepContext> action) =>
action == null
? stepBuilder
: stepBuilder?.Teardown(context =>
{
action(context);
return(Task.FromResult(0));
});
internal static IStepBuilder <TData, ToEquirectangular> ToEquirectangular <TStep, TData>(
this IStepBuilder <TData, TStep> builder)
where TStep : IStepBody
where TData : StitchWorkflowData
=> builder
.Then <TStep, ToEquirectangular, TData>("Reprojecting to equirectangular")
.WithRegistration()
.Input(step => step.SourceImage, data => data.Registration !.Image)
internal static IStepBuilder <TData, LoadImage> LoadImage <TStep, TData>(this IStepBuilder <TData, TStep> builder, Expression <Func <TData, IProgressBar?> > progressBar)
where TStep : IStepBody
where TData : WorkflowData
{
return(builder
.Then <TStep, LoadImage, TData>("Load image")
.Input(step => step.ProgressBar, progressBar)
.WithRegistration());
}
internal static IStepBuilder <TData, ShouldWrite> ShouldWrite <TStep, TData>(this IStepBuilder <TData, TStep> builder)
where TStep : IStepBody
where TData : EquirectangularTimelapseWorkflowData
=> builder
.Then <TStep, ShouldWrite, TData>()
.WithActivity()
.WithProgressBar()
.Input(step => step.Timestamp, data => data.TargetTimestamp)
.Output(data => data.AlreadyRenderedCount, step => step.AlreadyRenderedCount);
internal static IStepBuilder <TData, ShouldWrite> ShouldWrite <TStep, TData>(this IStepBuilder <TData, TStep> builder, DateTime?timestamp)
where TStep : IStepBody
where TData : WorkflowData
=> builder
.Then <TStep, ShouldWrite, TData>()
.WithActivity()
.WithProgressBar()
.Input(step => step.Timestamp, data => timestamp)
.Output(data => data.AlreadyRenderedCount, step => step.AlreadyRenderedCount);
internal static IStepBuilder <TData, SaveImage> SaveImage <TStep, TData>(this IStepBuilder <TData, TStep> builder)
where TStep : IStepBody
where TData : WorkflowData
=> builder
.Then <TStep, SaveImage, TData>("Save image")
.WithRegistration()
.Input(step => step.TargetImage, data => data.TargetImage)
.Input(step => step.RenderedCount, data => data.RenderedCount)
.Output(data => data.RenderedCount, step => step.RenderedCount);
internal static IStepBuilder <TData, CropImage> CropImage <TStep, TData>(this IStepBuilder <TData, TStep> builder)
where TStep : IStepBody
where TData : StitchWorkflowData
{
return(builder
.Then <TStep, CropImage, TData>("Crop image")
.WithActivity()
.Input(step => step.TargetImage, data => data.TargetImage)
.Input(step => step.CropBounds, data => data.CropBounds));
}
public IStepBuilder <TData, TStep> Then <TStep>(IStepBuilder <TData, TStep> newStep)
where TStep : IStepBody
{
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Step.Id
});
var stepBuilder = new StepBuilder <TData, TStep>(WorkflowBuilder, newStep.Step);
return(stepBuilder);
}
internal static IStepBuilder <TData, ToGeostationary> ToGeostationary <TStep, TData>(
this IStepBuilder <TData, TStep> builder,
Expression <Func <TData, double?> > longitude)
where TStep : IStepBody
where TData : WorkflowData
=> builder
.Then <TStep, ToGeostationary, TData>("Reprojecting to geostationary")
.WithActivity()
.Input(step => step.Longitude, longitude)
.Input(step => step.TargetImage, data => data.TargetImage)
.Output(data => data.TargetImage, step => step.TargetImage);
public IStepBuilder StartWith(Action action = null)
{
if (action is null)
{
_task = new Task(() => { });
}
else
{
_task = new Task(action);
}
IStepBuilder _stepBuilder = DependencyInjectionService.GetService <IStepBuilder>();
((StepBuilder)_stepBuilder).SetTask(_task);
return(_stepBuilder);
}
public IStepBuilder <TData, TStepBody> Branch <TStep>(object outcomeValue, IStepBuilder <TData, TStep> branch) where TStep : IStepBody
{
if (branch.WorkflowBuilder.Steps.Count == 0)
{
return(this);
}
WorkflowBuilder.AttachBranch(branch.WorkflowBuilder);
Expression <Func <object, object> > expr = x => outcomeValue;
Step.Outcomes.Add(new ValueOutcome
{
Value = expr,
NextStep = branch.WorkflowBuilder.Steps[0].Id
});
return(this);
}
internal static IStepBuilder <TData, ShouldWrite> ShouldWrite <TStep, TData>(
this IStepBuilder <TData, TStep> builder,
Expression <Func <TData, string?> >?identifier = null)
where TStep : IStepBody
where TData : TimelapseWorkflowData
{
var result = builder
.Then <TStep, ShouldWrite, TData>()
.WithActivity()
.WithProgressBar()
.Input(step => step.Timestamp, data => data.TargetTimestamp)
.Output(data => data.AlreadyRenderedCount, step => step.AlreadyRenderedCount);
if (identifier != null)
{
result.Input(step => step.Identifier, identifier);
}
return(result);
}
public static IStepBuilder <TData, UserStep> UserStep <TData, TStepBody>(this IStepBuilder <TData, TStepBody> builder, string userPrompt, Expression <Func <TData, string> > assigner, Action <IStepBuilder <TData, UserStep> > stepSetup = null)
where TStepBody : IStepBody
{
var newStep = new UserStepContainer();
newStep.Principal = assigner;
newStep.UserPrompt = userPrompt;
builder.WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, UserStep>(builder.WorkflowBuilder, newStep);
if (stepSetup != null)
{
stepSetup.Invoke(stepBuilder);
}
newStep.Name = newStep.Name ?? typeof(UserStepContainer).Name;
builder.Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public override void Build(IWorkflowBuilder <object> builder)
{
builder.StartWith(x => { })
.While(d => true)
.Do(x =>
{
var scheduleOptions = scheduleOptionRepository
.GetByWorkflow(Id)
.Where(o => o.Enabled);
var entities = entityRepository
.GetAll()
.Where(e => e.Enabled && scheduleOptions.Any(o => o.TargetEntityId == e.Id && o.TargetEntityType == e.EntityType));
var attributes = attributeRepository
.GetAll()
.Where(e => e.Enabled && scheduleOptions.Any(o => o.TargetEntityId == e.Id && o.TargetEntityType == e.EntityType));
var indexes = entities
.Select(e => e as IIndexModel)
.Union(attributes.Select(a => a as IIndexModel));
if (indexes == null || indexes.Count() <= 0)
{
x.StartWith(c => { })
.Delay(d => TimeSpan.FromMinutes(10));
}
IStepBuilder <object, QueueIndexChangesStep> ip = null;
foreach (var i in indexes)
{
if (ip == null)
{
ip = x.StartWith <QueueIndexChangesStep>()
.Input(s => s.IndexModel, d => i);
}
else
{
ip = ip.Then <QueueIndexChangesStep>()
.Input(s => s.IndexModel, d => i);
}
}
ip?.Delay(d => TimeSpan.FromSeconds(5));
});
}
public static IUserTaskBuilder <TData> UserTask <TData, TStepBody>(this IStepBuilder <TData, TStepBody> builder, string userPrompt, Expression <Func <TData, string> > assigner, Action <IStepBuilder <TData, UserTask> > stepSetup = null)
where TStepBody : IStepBody
{
var newStep = new UserTaskStep();
builder.WorkflowBuilder.AddStep(newStep);
var stepBuilder = new UserTaskBuilder <TData>(builder.WorkflowBuilder, newStep);
stepBuilder.Input(step => step.AssignedPrincipal, assigner);
stepBuilder.Input(step => step.Prompt, data => userPrompt);
if (stepSetup != null)
{
stepSetup.Invoke(stepBuilder);
}
newStep.Name = newStep.Name ?? typeof(UserTask).Name;
builder.Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public ReturnStepBuilder(IWorkflowBuilder <TData> workflowBuilder, WorkflowStep <TStepBody> step, IStepBuilder <TData, TParentStep> referenceBuilder)
{
WorkflowBuilder = workflowBuilder;
Step = step;
_referenceBuilder = referenceBuilder;
}
internal static IStepBuilder <TData, CalculateVisibleRange> CalculateVisibleRange <TStep, TData>(this IStepBuilder <TData, TStep> builder)
where TStep : IStepBody
where TData : WorkflowData
=> builder
.Then <TStep, CalculateVisibleRange, TData>("Calculate visible range")
.WithActivity();
internal static IStepBuilder <TData, CreateActivities> CreateActivities <TStep, TData>(this IStepBuilder <TData, TStep> builder)
where TStep : IStepBody
where TData : EquirectangularTimelapseWorkflowData
=> builder
.Then <TStep, CreateActivities, TData>("Create activities")
.Input(step => step.SourceRegistrations, data => data.SourceRegistrations)
.Input(step => step.Timestamp, data => data.TargetTimestamp)
.Input(step => step.NumTimeIntervals, data => data.TimeIntervals.Count)
.Output(data => data.Activity, step => step.Activity);
internal static IStepBuilder <TData, ToEquirectangular> ToEquirectangular <TStep, TData>(this IStepBuilder <TData, TStep> builder)
where TStep : IStepBody
where TData : EquirectangularStitchWorkflowData
=> builder
.Then <TStep, ToEquirectangular, TData>("Reprojecting to equirectangular")
.WithRegistration()
.Input(step => step.GlobalOffset, data => data.GlobalOffset);
internal static IStepBuilder <TData, StitchImages> StitchImages <TStep, TData>(this IStepBuilder <TData, TStep> builder)
where TStep : IStepBody
where TData : StitchWorkflowData
{
return(builder
.Then <TStep, StitchImages, TData>("Stitch images")
.WithRegistration()
.WithActivity()
.Output(data => data.TargetImage, step => step.TargetImage));
}
/// <summary>
/// Renders an overlay on a registration image.
/// </summary>
internal static IStepBuilder <TData, RenderOverlay> RenderOverlay <TStep, TData>(this IStepBuilder <TData, TStep> builder)
where TStep : IStepBody
where TData : WorkflowData
=> builder
.Then <TStep, RenderOverlay, TData>("Render overlay")
.Input(step => step.SourceImage, data => data.Registration !.Image)
internal static IStepBuilder <EquirectangularWorkflowData, RegisterImages> RegisterImages <TStep>(this IStepBuilder <EquirectangularWorkflowData, TStep> builder)
where TStep : IStepBody
=> builder
.Then <TStep, RegisterImages, EquirectangularWorkflowData>("Register images")
.Input(step => step.SourceRegistrations, data => data.SourceRegistrations)
.Output(data => data.Activities, step => step.Activities);
public IStepBuilder <TData, TStepBody> Branch <TStep>(Expression <Func <TData, object, bool> > outcomeExpression, IStepBuilder <TData, TStep> branch) where TStep : IStepBody
{
if (branch.WorkflowBuilder.Steps.Count == 0)
{
return(this);
}
WorkflowBuilder.AttachBranch(branch.WorkflowBuilder);
Step.Outcomes.Add(new ExpressionOutcome <TData>(outcomeExpression)
{
NextStep = branch.WorkflowBuilder.Steps[0].Id
});
return(this);
}
internal static IStepBuilder <GeostationaryWorkflowData, RenderUnderlay> RenderUnderlay <TStep>(this IStepBuilder <GeostationaryWorkflowData, TStep> builder)
where TStep : IStepBody
=> builder
.Then <TStep, RenderUnderlay, GeostationaryWorkflowData>("Render underlay")
.WithRegistration()
.Output(data => data.TargetImage, step => step.TargetImage);
