/// <summary>
/// Fetches the type of the execution.
/// </summary>
/// <param name="dataObject">The data object.</param>
/// <param name="environment"></param>
/// <param name="errors">The errors.</param>
/// <param name="update"></param>
/// <returns></returns>
private ForEachBootstrapTO FetchExecutionType(IDSFDataObject dataObject, IExecutionEnvironment environment, out ErrorResultTO errors, int update)
{
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams(ForEachType.GetDescription(), ""), debugItem);
if (ForEachType == enForEachType.NumOfExecution && !string.IsNullOrEmpty(NumOfExections))
{
AddDebugItem(new DebugEvalResult(NumOfExections, "Number", environment, update), debugItem);
}
if (ForEachType == enForEachType.InCSV && !string.IsNullOrEmpty(CsvIndexes))
{
AddDebugItem(new DebugEvalResult(CsvIndexes, "Csv Indexes", environment, update), debugItem);
}
if (ForEachType == enForEachType.InRange && !string.IsNullOrEmpty(From))
{
AddDebugItem(new DebugEvalResult(From, "From", environment, update), debugItem);
}
if (ForEachType == enForEachType.InRange && !string.IsNullOrEmpty(To))
{
AddDebugItem(new DebugEvalResult(To, "To", environment, update), debugItem);
}
if (ForEachType == enForEachType.InRecordset && !string.IsNullOrEmpty(Recordset))
{
AddDebugItem(new DebugEvalResult(ExecutionEnvironment.GetPositionColumnExpression(Recordset), "Recordset ", environment, update), debugItem);
}
_debugInputs.Add(debugItem);
}
var result = new ForEachBootstrapTO(ForEachType, From, To, CsvIndexes, NumOfExections, Recordset, environment, out errors, update);
return(result);
}
public void ForEachBootstrapTO_Constructor_IsNewRecordSetNoValue_AddError()
{
//------------Setup for test--------------------------
ErrorResultTO errors;
var envMock = new ExecutionEnvironment();
var forEachBootstrapTO = new ForEachBootstrapTO(enForEachType.InRecordset, "", "", "", "", "", envMock, out errors, 0);
//------------Execute Test---------------------------
Assert.IsNotNull(forEachBootstrapTO);
//------------Assert Results-------------------------
Assert.IsNotNull(errors);
Assert.AreEqual(1, errors.FetchErrors().Count);
}
public void ForEachBootstrapTO_Constructor_IsNewInRangeMinAndMax_NoError()
{
//------------Setup for test--------------------------
ErrorResultTO errors;
var envMock = new ExecutionEnvironment();
var forEachBootstrapTO = new ForEachBootstrapTO(enForEachType.InRange, "1", "3", "", "", "", envMock, out errors, 0);
//------------Execute Test---------------------------
Assert.IsNotNull(forEachBootstrapTO);
//------------Assert Results-------------------------
Assert.IsNotNull(errors);
Assert.AreEqual(0, errors.FetchErrors().Count);
}
public void ForEachBootstrapTO_Constructor_IsNewCsvValue_NoError()
{
//------------Setup for test--------------------------
ErrorResultTO errors;
var envMock = new ExecutionEnvironment();
var forEachBootstrapTO = new ForEachBootstrapTO(enForEachType.InCSV, "", "", "1,2,3", "", "", envMock, out errors, 0);
//------------Execute Test---------------------------
Assert.IsNotNull(forEachBootstrapTO);
//------------Assert Results-------------------------
Assert.IsNotNull(errors);
Assert.AreEqual(0, errors.FetchErrors().Count);
Assert.AreEqual(forEachBootstrapTO.ExeType, enForEachExecutionType.Scalar);
}
public void ForEachBootstrapTO_Constructor_IsNewRecordSetValue_NoError()
{
//------------Setup for test--------------------------
ErrorResultTO errors;
var envMock = new ExecutionEnvironment();
envMock.Assign("[[rec().a]]", "Hello There", 1);
var forEachBootstrapTO = new ForEachBootstrapTO(enForEachType.InRecordset, "", "", "", "", "[[rec()]]", envMock, out errors, 0);
//------------Execute Test---------------------------
Assert.IsNotNull(forEachBootstrapTO);
//------------Assert Results-------------------------
Assert.IsNotNull(errors);
Assert.AreEqual(0, errors.FetchErrors().Count);
}
public void ForEachBootstrapTO_Constructor_IsNewRecordSetNoValueNoInVaribaleList_AddError()
{
//------------Setup for test--------------------------
ErrorResultTO errors;
var envMock = new Mock <IExecutionEnvironment>();
envMock.Setup(environment => environment.EvalRecordSetIndexes("[[rec2()]]", It.IsAny <int>())).Verifiable();
envMock.Setup(environment => environment.HasRecordSet("[[rec2()]]")).Returns(false).Verifiable();
var forEachBootstrapTO = new ForEachBootstrapTO(enForEachType.InRecordset, "", "", "", "", "[[rec2()]]", envMock.Object, out errors, 0);
//------------Execute Test---------------------------
Assert.IsNotNull(forEachBootstrapTO);
//------------Assert Results-------------------------
Assert.IsNotNull(errors);
Assert.AreEqual(1, errors.FetchErrors().Count);
}
/// <summary>
/// Fetches the type of the execution.
/// </summary>
/// <param name="dataObject">The data object.</param>
/// <param name="dlId">The dl ID.</param>
/// <param name="compiler">The compiler.</param>
/// <param name="errors">The errors.</param>
/// <returns></returns>
private ForEachBootstrapTO FetchExecutionType(IDSFDataObject dataObject, Guid dlId, IDataListCompiler compiler, out ErrorResultTO errors)
{
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams(ForEachType.GetDescription(), ""), debugItem);
if (ForEachType == enForEachType.NumOfExecution && !string.IsNullOrEmpty(NumOfExections))
{
IBinaryDataListEntry numOfExectionsEntry = compiler.Evaluate(dlId, enActionType.User, NumOfExections, false, out errors);
AddDebugItem(new DebugItemVariableParams(NumOfExections, "Number", numOfExectionsEntry, dlId), debugItem);
}
if (ForEachType == enForEachType.InCSV && !string.IsNullOrEmpty(CsvIndexes))
{
IBinaryDataListEntry csvIndexesEntry = compiler.Evaluate(dlId, enActionType.User, CsvIndexes, false, out errors);
AddDebugItem(new DebugItemVariableParams(CsvIndexes, "Csv Indexes", csvIndexesEntry, dlId), debugItem);
}
if (ForEachType == enForEachType.InRange && !string.IsNullOrEmpty(From))
{
IBinaryDataListEntry fromEntry = compiler.Evaluate(dlId, enActionType.User, From, false, out errors);
AddDebugItem(new DebugItemVariableParams(From, "From", fromEntry, dlId), debugItem);
}
if (ForEachType == enForEachType.InRange && !string.IsNullOrEmpty(To))
{
IBinaryDataListEntry toEntry = compiler.Evaluate(dlId, enActionType.User, To, false, out errors);
AddDebugItem(new DebugItemVariableParams(To, "To", toEntry, dlId), debugItem);
}
if (ForEachType == enForEachType.InRecordset && !string.IsNullOrEmpty(Recordset))
{
var toEmit = Recordset.Replace("()", "(*)");
IBinaryDataListEntry toEntry = compiler.Evaluate(dlId, enActionType.User, toEmit, false, out errors);
AddDebugItem(new DebugItemVariableParams(toEmit, "Recordset", toEntry, dlId), debugItem);
}
_debugInputs.Add(debugItem);
}
var result = new ForEachBootstrapTO(ForEachType, From, To, CsvIndexes, NumOfExections, Recordset, dlId, compiler, out errors);
return(result);
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_previousParentId = dataObject.ParentInstanceID;
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
ErrorResultTO allErrors = new ErrorResultTO();
IIndexIterator itr = null;
InitializeDebug(dataObject);
dataObject.ForEachNestingLevel++;
try
{
ErrorResultTO errors;
ForEachBootstrapTO exePayload = FetchExecutionType(dataObject, dataObject.Environment, out errors, update);
foreach (var err in errors.FetchErrors())
{
dataObject.Environment.AddError(err);
}
itr = exePayload.IndexIterator;
string error;
ForEachInnerActivityTO innerA = GetInnerActivity(out error);
var exeAct = innerA?.InnerActivity;
allErrors.AddError(error);
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
}
dataObject.ParentInstanceID = UniqueID;
dataObject.IsDebugNested = true;
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.After, update);
}
exePayload.InnerActivity = innerA;
while (itr?.HasMore() ?? false)
{
operationalData = exePayload;
int idx = exePayload.IndexIterator.FetchNextIndex();
int innerupdate = 0;
if (exePayload.ForEachType != enForEachType.NumOfExecution)
{
innerupdate = idx;
}
_childUniqueID = exeAct?.UniqueID;
exeAct?.Execute(dataObject, innerupdate);
operationalData.IncIterationCount();
}
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
}
}
catch (Exception e)
{
Dev2Logger.Error("DSFForEach", e);
allErrors.AddError(e.Message);
}
finally
{
if (itr != null)
{
if (ForEachType != enForEachType.NumOfExecution)
{
RestoreHandlerFn();
}
}
var serviceTestStep = dataObject.ServiceTest?.TestSteps?.Flatten(step => step.Children)?.FirstOrDefault(step => step.UniqueId == _originalUniqueID);
if (dataObject.IsServiceTestExecution)
{
var serviceTestSteps = serviceTestStep?.Children;
UpdateDebugStateWithAssertions(dataObject, serviceTestSteps?.ToList());
if (serviceTestStep != null)
{
var testRunResult = new TestRunResult();
GetFinalTestRunResult(serviceTestStep, testRunResult);
serviceTestStep.Result = testRunResult;
}
}
dataObject.ParentInstanceID = _previousParentId;
dataObject.ForEachNestingLevel--;
dataObject.IsDebugNested = false;
if (dataObject.IsDebugMode())
{
if (dataObject.IsServiceTestExecution && serviceTestStep != null)
{
var debugItems = TestDebugMessageRepo.Instance.GetDebugItems(dataObject.ResourceID, dataObject.TestName);
debugItems = debugItems.Where(state => state.WorkSurfaceMappingId == serviceTestStep.UniqueId).ToList();
var debugStates = debugItems.LastOrDefault();
var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(serviceTestStep.Result.Message, serviceTestStep.Result.RunTestResult == RunResult.TestFailed);
DebugItem itemToAdd = new DebugItem();
itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
debugStates?.AssertResultList?.Add(itemToAdd);
}
DispatchDebugState(dataObject, StateType.Duration, 0);
}
// Handle Errors
if (allErrors.HasErrors())
{
dataObject.ParentInstanceID = _previousParentId;
dataObject.ForEachNestingLevel--;
dataObject.IsDebugNested = false;
// Handle Errors
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfForEachActivity", allErrors);
foreach (var fetchError in allErrors.FetchErrors())
{
dataObject.Environment.AddError(fetchError);
}
dataObject.ParentInstanceID = _previousParentId;
}
}
}
}
protected override void OnExecute(NativeActivityContext context)
{
lock (_forEachExecutionObject)
{
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
dataObject.ForEachNestingLevel++;
ErrorResultTO allErrors = new ErrorResultTO();
InitializeDebug(dataObject);
try
{
ErrorResultTO errors;
ForEachBootstrapTO exePayload = FetchExecutionType(dataObject, dataObject.Environment, out errors, 0);
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
return;
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, 0);
}
dataObject.ParentInstanceID = UniqueID;
allErrors.MergeErrors(errors);
string error;
ForEachInnerActivityTO innerA = GetInnerActivity(out error);
allErrors.AddError(error);
exePayload.InnerActivity = innerA;
operationalData = exePayload;
// flag it as scoped so we can use a single DataList
dataObject.IsDataListScoped = true;
dataObject.IsDebugNested = true;
if (exePayload.InnerActivity != null && exePayload.IndexIterator.HasMore())
{
int idx = exePayload.IndexIterator.FetchNextIndex();
if (exePayload.ForEachType != enForEachType.NumOfExecution)
{
IterateIOMapping(idx);
}
else
{
dataObject.IsDataListScoped = false;
}
// schedule the func to execute ;)
dataObject.ParentInstanceID = UniqueID;
context.ScheduleFunc(DataFunc, string.Empty, ActivityCompleted);
}
}
catch (Exception e)
{
Dev2Logger.Error("DSFForEach", e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfForEachActivity", allErrors);
foreach (var fetchError in allErrors.FetchErrors())
{
dataObject.Environment.AddError(fetchError);
}
dataObject.ParentInstanceID = _previousParentId;
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.After, 0);
}
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject)
{
_previousParentId = dataObject.ParentInstanceID;
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
dataObject.ForEachNestingLevel++;
ErrorResultTO allErrors = new ErrorResultTO();
InitializeDebug(dataObject);
try
{
ErrorResultTO errors;
ForEachBootstrapTO exePayload = FetchExecutionType(dataObject, dataObject.Environment, out errors);
var itr = exePayload.IndexIterator;
string error;
ForEachInnerActivityTO innerA = GetInnerActivity(out error);
var exeAct = innerA.InnerActivity;
allErrors.AddError(error);
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before);
}
dataObject.ParentInstanceID = UniqueID;
dataObject.IsDebugNested = true;
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.After);
}
exePayload.InnerActivity = innerA;
var ind = itr.MaxIndex();
var count = 0;
while (itr.HasMore() && count < ind)
{
operationalData = exePayload;
int idx = exePayload.IndexIterator.FetchNextIndex();
if (exePayload.ForEachType != enForEachType.NumOfExecution)
{
IterateIOMapping(idx);
}
exeAct.Execute(dataObject);
count++;
}
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFForEach", e);
allErrors.AddError(e.Message);
}
finally
{
if (ForEachType != enForEachType.NumOfExecution)
{
RestoreHandlerFn();
}
dataObject.ParentInstanceID = _previousParentId;
dataObject.ForEachNestingLevel--;
dataObject.IsDebugNested = false;
// Handle Errors
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfForEachActivity", allErrors);
foreach (var fetchError in allErrors.FetchErrors())
{
dataObject.Environment.AddError(fetchError);
}
dataObject.ParentInstanceID = _previousParentId;
}
}
}
