protected void AddStep(IProcessStep step)
{
step.Complete += StepComplete;
_steps.AddLast(step);
CurrentStep = step;
}
public void AddStep(IProcessStep processStep)
{
if (processStep == null)
{
throw new ArgumentNullException(nameof(processStep));
}
steps.Add(processStep);
}
public void SetNext(IProcessStep <T> step)
{
if (this.Next == null)
{
this.next = step;
}
else
{
this.Next.SetNext(step);
}
}
public void Step()
{
if (!OnLastStep())
{
var index = steps.FindIndex((test) => current == test);
current = steps[index + 1];
return;
}
if (RotateToStartWhenDone)
{
current = steps.First();
return;
}
current = null;
}
public void Start()
{
current = steps.First();
Run();
}
public void Cancel()
{
steps.ForEach(step => step?.Cancel());
current = null;
}
public void ArchiveHistoryForStep(IProcessExecutionContext executionContext, IWorkSession session, IProcessStep processStep, bool isRolledBack = false)
{
var historyRecord = GetHistoryForStep(processStep) as StepHistory;
var statusCode = isRolledBack ? eProcessStepHistoryStatusEnum.RolledBack : eProcessStepHistoryStatusEnum.Archived;
historyRecord.StepStatus = statusCode;
DataConnector.UpdateStepHistoryStatus(executionContext.DataService, historyRecord, statusCode);
}
public void AddToHistory(IProcessExecutionContext executionContext, IWorkSession session, IProcessStep processStep, bool isExecuted)
{
if (executionContext is null)
{
throw new ArgumentNullException("executionContext");
}
if (session is null)
{
throw new ArgumentNullException("workSession");
}
if (processStep is null)
{
throw new ArgumentNullException("processStep");
}
var lastHistory = this.Records.LastOrDefault();
var lastCurrentHistory = this.Records.Where(r => r.StepStatus == eProcessStepHistoryStatusEnum.Current).LastOrDefault();
//create a new history record for the passed in process step and
//link it back to last current history step in the list.
var newHistory = DataConnector.CreateStepHistoryRecord(
executionContext.DataService,
this.Transaction,
processStep,
lastCurrentHistory);
this.Records.Add(new StepHistory(newHistory));
// Update the starting history in the database.
if (lastHistory != null)
{
//Update local copy.
lastHistory.NextStepId = newHistory;
lastHistory.CompletedById = isExecuted ? session.Agent : null;
lastHistory.CompletedAtId = isExecuted ? session.Location : null;
//update database.
DataConnector.UpdateStepHistoryRecord(
executionContext.DataService,
lastHistory,
newHistory,
isExecuted ? session.Agent : null,
isExecuted ? session.Location : null,
isExecuted ? (DateTime?)DateTime.Now : null);
}
}
public IStepHistory GetHistoryForStep(IProcessStep processStep)
{
return(this.Records.Where(r =>
r.StepStatus == eProcessStepHistoryStatusEnum.Current &&
r.ProcessStepId.Id == processStep.Id).FirstOrDefault() ?? throw new Exception("Unable to find current history for specified step."));
}
public void ContinueTo(IProcessStep nextStep)
{
RemoveAllStepsAfterCurrent();
AddStep(nextStep);
}
public void Reset()
{
CurrentStep = null;
_steps.Clear();
CreateFirstStep();
}
public IProcessStep NavigateForward(IWorkSession session)
{
try
{
if (!this.CanNavigateForward(session))
{
throw TransactionException.BuildException(TransactionException.ErrorCode.ActionNotAvailable);
}
// If the navigation gets blocked by a validation issue then the navigation process must fall back to the step
// it started on.
var fallbackStepId = this.CurrentStepId;
IProcessStep startingStep = this.CurrentStep;
IProcessStep nextStep = null;
bool isBlocked = false;
while (true)
{
// Get the step history record for the starting step. This record should always exist.
IStepHistory stepHistory = this.TransactionHistory.GetHistoryForStep(startingStep);
if (stepHistory is null)
{
throw TransactionException.BuildException(TransactionException.ErrorCode.StepHistoryNotFound);
}
bool hasExecuted = stepHistory.CompletedOn.HasValue;
if (!hasExecuted)
{
ExecutionContext.Trace("Getting next step by executing current step.");
// When the step has not been executed we need to execute it to find out what the next step in the
// processes is because steps with conditional branching do not know the next step until execution.
//
// Additionally, any validation requirements associated with the step will be evaluated and this could
// result in blocking forward navigation. In this case we still update the step history to show that the
// step was executed.
var executionResult = startingStep.Execute(ExecutionContext, session, this, RequirementEvaluator);
nextStep = executionResult.NextStep;
isBlocked = executionResult.StepIsBlocked; //validation requirements may block further advancement.
this.TransactionHistory.AddToHistory(this.ExecutionContext, session, nextStep, true);
}
else
{
ExecutionContext.Trace("Getting next step from step history");
if (stepHistory.NextStepId is null)
{
throw TransactionException.BuildException(TransactionException.ErrorCode.StepHistoryInvalid);
}
var nextStepId = this.TransactionHistory.GetHistoryById(stepHistory.NextStepId).ProcessStepId;
// When the step has executed then we just get the next step based on history.
nextStep = this.CurrentProcess.ProcessSteps.Where(r => Id == nextStepId.Id).FirstOrDefault();
}
// Stop moving forward when a UI step is found or when the step represents the last step in the process or
// when additional execution is blocked.
if (isBlocked || nextStep is null || nextStep.IsLastStep() || nextStep.Type.IsUIStep)
{
break;
}
// advance to the next process step and run through the loop again
startingStep = nextStep;
}
// When any execution in this step is blocked because of validation then the process falls back to
// the step that was current before we started. However any items that were completed in the above loop
if (isBlocked)
{
this.CurrentStepId = fallbackStepId;
return(this.CurrentStep);
}
// save the current step to the data base.
this.CurrentStepId = nextStep;
this.TransactionService.SaveTransactionCurrentStep(this.ExecutionContext, this, this.CurrentStepId);
return(this.CurrentStep);
}
catch (Exception ex)
{
throw TransactionException.BuildException(TransactionException.ErrorCode.ProcessNavigationError, ex);
}
}
private ActionResult RedirectTo(IProcessStep step)
{
return new RedirectToRouteResult(step.RouteValues);
}
internal GoToNextStepCommand(IProcessStep nextStep)
{
_nextStep = nextStep;
}
