public IContainerStepBuilder <TData, Schedule, TStepBody> Schedule(Expression <Func <TData, TimeSpan> > time)
{
var newStep = new WorkflowStep <Schedule>();
Expression <Func <Schedule, TimeSpan> > inputExpr = (x => x.Interval);
newStep.Inputs.Add(new MemberMapParameter(time, inputExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new ReturnStepBuilder <TData, Schedule, TStepBody>(WorkflowBuilder, newStep, this);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
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);
}
public IStepBuilder <TData, Sequence> Saga(Action <IWorkflowBuilder <TData> > builder)
{
var newStep = new SagaContainer <Sequence>();
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, Sequence>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new StepOutcome()
{
NextStep = newStep.Id
});
builder.Invoke(WorkflowBuilder);
stepBuilder.Step.Children.Add(stepBuilder.Step.Id + 1); //TODO: make more elegant
return(stepBuilder);
}
public IStepBuilder <TData, InlineStepBody> Then(Func <IStepExecutionContext, ExecutionResult> body)
{
WorkflowStepInline newStep = new WorkflowStepInline
{
Body = body
};
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, InlineStepBody>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new StepOutcome()
{
NextStep = newStep.Id
});
return(stepBuilder);
}
public IStepBuilder <TData, Decide> Decide(Expression <Func <TData, object> > expression)
{
var newStep = new WorkflowStep <Decide>();
Expression <Func <Decide, object> > inputExpr = (x => x.Expression);
newStep.Inputs.Add(new MemberMapParameter(expression, inputExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, Decide>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public IStepBuilder <TData, Delay> Delay(Expression <Func <TData, TimeSpan> > period)
{
var newStep = new WorkflowStep <Delay>();
Expression <Func <Delay, TimeSpan> > inputExpr = (x => x.Period);
newStep.Inputs.Add(new MemberMapParameter(period, inputExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, Delay>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public IContainerStepBuilder <TData, Foreach, Foreach> ForEach(Expression <Func <TData, IEnumerable> > collection)
{
var newStep = new WorkflowStep <Foreach>();
Expression <Func <Foreach, IEnumerable> > inputExpr = (x => x.Collection);
newStep.Inputs.Add(new MemberMapParameter(collection, inputExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, Foreach>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public IStepBuilder <TData, TStepBody> CompensateWith <TStep>(Action <IStepBuilder <TData, TStep> > stepSetup = null) where TStep : IStepBody
{
WorkflowStep <TStep> newStep = new WorkflowStep <TStep>();
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, TStep>(WorkflowBuilder, newStep);
if (stepSetup != null)
{
stepSetup.Invoke(stepBuilder);
}
newStep.Name = newStep.Name ?? typeof(TStep).Name;
Step.CompensationStepId = newStep.Id;
return(this);
}
public IContainerStepBuilder <TData, If, If> If(Expression <Func <TData, bool> > condition)
{
var newStep = new WorkflowStep <If>();
Expression <Func <If, bool> > inputExpr = (x => x.Condition);
newStep.Inputs.Add(new MemberMapParameter(condition, inputExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, If>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public IStepBuilder <TData, TStep> Then <TStep>(Action <IStepBuilder <TData, TStep> > stepSetup = null)
where TStep : IStepBody
{
WorkflowStep <TStep> step = new WorkflowStep <TStep>();
WorkflowBuilder.AddStep(step);
var stepBuilder = new StepBuilder <TData, TStep>(WorkflowBuilder, step);
if (stepSetup != null)
{
stepSetup.Invoke(stepBuilder);
}
step.Name = step.Name ?? typeof(TStep).Name;
Outcome.NextStep = step.Id;
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);
}
public IStepBuilder <TData, TStep> Then <TStep>(Action <IStepBuilder <TData, TStep> > stepSetup = null)
where TStep : IStepBody
{
WorkflowStep <TStep> newStep = new WorkflowStep <TStep>();
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, TStep>(WorkflowBuilder, newStep);
if (stepSetup != null)
{
stepSetup.Invoke(stepBuilder);
}
newStep.Name = newStep.Name ?? typeof(TStep).Name;
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public IContainerStepBuilder <TData, Recur, TStepBody> Recur(Expression <Func <TData, TimeSpan> > interval, Expression <Func <TData, bool> > until)
{
var newStep = new WorkflowStep <Recur>();
newStep.CancelCondition = until;
Expression <Func <Recur, TimeSpan> > intervalExpr = (x => x.Interval);
Expression <Func <Recur, bool> > untilExpr = (x => x.StopCondition);
newStep.Inputs.Add(new MemberMapParameter(interval, intervalExpr));
newStep.Inputs.Add(new MemberMapParameter(until, untilExpr));
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new ReturnStepBuilder <TData, Recur, TStepBody>(WorkflowBuilder, newStep, this);
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
public IStepBuilder <TData, WaitFor> WaitFor(string eventName, Expression <Func <TData, IStepExecutionContext, string> > eventKey, Expression <Func <TData, DateTime> > effectiveDate = null)
{
var newStep = new WorkflowStep <WaitFor>();
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, WaitFor>(WorkflowBuilder, newStep);
stepBuilder.Input((step) => step.EventName, (data) => eventName);
stepBuilder.Input((step) => step.EventKey, eventKey);
if (effectiveDate != null)
{
stepBuilder.Input((step) => step.EffectiveDate, effectiveDate);
}
Step.Outcomes.Add(new StepOutcome()
{
NextStep = newStep.Id
});
return(stepBuilder);
}
public IStepBuilder <TData, WaitFor> WaitFor(string eventName, Expression <Func <TData, string> > eventKey, Expression <Func <TData, DateTime> > effectiveDate = null, Expression <Func <TData, bool> > cancelCondition = null)
{
var newStep = new WorkflowStep <WaitFor>();
newStep.CancelCondition = cancelCondition;
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, WaitFor>(WorkflowBuilder, newStep);
stepBuilder.Input((step) => step.EventName, (data) => eventName);
stepBuilder.Input((step) => step.EventKey, eventKey);
if (effectiveDate != null)
{
stepBuilder.Input((step) => step.EffectiveDate, effectiveDate);
}
Step.Outcomes.Add(new ValueOutcome {
NextStep = newStep.Id
});
return(stepBuilder);
}
private WorkflowStep IterateParents(int id, string name)
{
//todo: filter out circular paths
var upstream = WorkflowBuilder.GetUpstreamSteps(id);
foreach (var parent in upstream)
{
if (parent.Name == name)
{
return(parent);
}
}
foreach (var parent in upstream)
{
var result = IterateParents(parent.Id, name);
if (result != null)
{
return(result);
}
}
return(null);
}
public IContainerStepBuilder <TData, Schedule, TStepBody> Schedule(Expression <Func <TData, TimeSpan> > time)
{
var newStep = new WorkflowStep <Schedule>();
Expression <Func <Schedule, TimeSpan> > inputExpr = (x => x.Interval);
var mapping = new DataMapping()
{
Source = time,
Target = inputExpr
};
newStep.Inputs.Add(mapping);
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new ReturnStepBuilder <TData, Schedule, TStepBody>(WorkflowBuilder, newStep, this);
Step.Outcomes.Add(new StepOutcome()
{
NextStep = newStep.Id
});
return(stepBuilder);
}
public IContainerStepBuilder <TData, When, OutcomeSwitch> When(Expression <Func <TData, object> > outcomeValue, string label = null)
{
var newStep = new WorkflowStep <When>();
Expression <Func <When, object> > inputExpr = (x => x.ExpectedOutcome);
var mapping = new DataMapping()
{
Source = outcomeValue,
Target = inputExpr
};
newStep.Inputs.Add(mapping);
IStepBuilder <TData, OutcomeSwitch> switchBuilder;
if (Step.BodyType != typeof(OutcomeSwitch))
{
var switchStep = new WorkflowStep <OutcomeSwitch>();
WorkflowBuilder.AddStep(switchStep);
Step.Outcomes.Add(new StepOutcome()
{
NextStep = switchStep.Id,
Label = label
});
switchBuilder = new StepBuilder <TData, OutcomeSwitch>(WorkflowBuilder, switchStep);
}
else
{
switchBuilder = (this as IStepBuilder <TData, OutcomeSwitch>);
}
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new SkipStepBuilder <TData, When, OutcomeSwitch>(WorkflowBuilder, newStep, switchBuilder);
switchBuilder.Step.Children.Add(newStep.Id);
return(stepBuilder);
}
public IContainerStepBuilder <TData, If, If> If(Expression <Func <TData, bool> > condition)
{
var newStep = new WorkflowStep <If>();
Expression <Func <If, bool> > inputExpr = (x => x.ConditionResult);
var mapping = new DataMapping()
{
Source = condition,
Target = inputExpr
};
newStep.Inputs.Add(mapping);
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, If>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new StepOutcome()
{
NextStep = newStep.Id
});
return(stepBuilder);
}
public IContainerStepBuilder <TData, Foreach, Foreach> ForEach(Expression <Func <TData, IEnumerable> > collection)
{
var newStep = new WorkflowStep <Foreach>();
Expression <Func <Foreach, IEnumerable> > inputExpr = (x => x.Collection);
var mapping = new DataMapping()
{
Source = collection,
Target = inputExpr
};
newStep.Inputs.Add(mapping);
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, Foreach>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new StepOutcome()
{
NextStep = newStep.Id
});
return(stepBuilder);
}
public IStepBuilder <TData, Delay> Delay(Expression <Func <TData, TimeSpan> > period)
{
var newStep = new WorkflowStep <Delay>();
Expression <Func <Delay, TimeSpan> > inputExpr = (x => x.Period);
var mapping = new DataMapping()
{
Source = period,
Target = inputExpr
};
newStep.Inputs.Add(mapping);
WorkflowBuilder.AddStep(newStep);
var stepBuilder = new StepBuilder <TData, Delay>(WorkflowBuilder, newStep);
Step.Outcomes.Add(new StepOutcome()
{
NextStep = newStep.Id
});
return(stepBuilder);
}
public IWorkflowBuilder <T> UseData <T>()
{
IWorkflowBuilder <T> result = new WorkflowBuilder <T>(Steps);
return(result);
}