static Dev2DecisionStack SetupTos(IEnumerable <IDev2TOFn> valuecoll)
{
var val = new Dev2DecisionStack {
TheStack = new List <Dev2Decision>()
};
var value = valuecoll.Select(a => a as DecisionTO);
foreach (var decisionTo in value.Where(a => { return(a != null && !a.IsEmpty()); }))
{
var dev2Decision = new Dev2Decision {
Col1 = decisionTo.MatchValue
};
if (!string.IsNullOrEmpty(decisionTo.SearchCriteria))
{
dev2Decision.Col2 = decisionTo.SearchCriteria;
}
dev2Decision.EvaluationFn = DecisionDisplayHelper.GetValue(decisionTo.SearchType);
if (decisionTo.IsBetweenCriteriaVisible)
{
dev2Decision.Col2 = decisionTo.From;
dev2Decision.Col3 = decisionTo.To;
}
if (string.IsNullOrEmpty(dev2Decision.Col3))
{
dev2Decision.Col3 = "";
}
val.TheStack.Add(dev2Decision);
}
return(val);
}
// Travis.Frisinger - 28.01.2013 : Amended for Debug
public override List <DebugItem> GetDebugOutputs(IBinaryDataList dataList)
{
var result = new List <DebugItem>();
string resultString = _theResult.ToString();
DebugItem itemToAdd = new DebugItem();
IDataListCompiler c = DataListFactory.CreateDataListCompiler();
var val = new StringBuilder(Dev2DecisionStack.ExtractModelFromWorkflowPersistedData(ExpressionText));
try
{
Dev2DecisionStack dds = c.ConvertFromJsonToModel <Dev2DecisionStack>(val);
if (_theResult.ToString() == "True")
{
resultString = dds.TrueArmText;
}
else if (_theResult.ToString() == "False")
{
resultString = dds.FalseArmText;
}
itemToAdd.AddRange(new DebugItemStaticDataParams(resultString, "").GetDebugItemResult());
result.Add(itemToAdd);
}
catch (Exception)
{
if (!dataList.HasErrors())
{
itemToAdd.AddRange(new DebugItemStaticDataParams(resultString, "").GetDebugItemResult());
result.Add(itemToAdd);
}
}
return(result);
}
IEnumerable <IDev2Activity> ParseSwitch(FlowSwitch <string> switchFlowSwitch, List <IDev2Activity> seenActivities)
{
var activity = switchFlowSwitch.Expression as DsfFlowSwitchActivity;
if (activity != null)
{
if (seenActivities.Contains(activity))
{
return(new List <IDev2Activity> {
activity
});
}
var val = new StringBuilder(Dev2DecisionStack.ExtractModelFromWorkflowPersistedData(activity.ExpressionText));
Dev2Switch ds = new Dev2Switch {
SwitchVariable = val.ToString()
};
var swi = new DsfSwitch(activity);
if (!seenActivities.Contains(activity))
{
seenActivities.Add(swi);
}
swi.Switches = switchFlowSwitch.Cases.Select(a => new Tuple <string, IDev2Activity>(a.Key, ParseTools(a.Value, seenActivities).FirstOrDefault())).ToDictionary(a => a.Item1, a => a.Item2);
swi.Default = ParseTools(switchFlowSwitch.Default, seenActivities);
swi.Switch = ds.SwitchVariable;
return(new List <IDev2Activity>
{
swi
});
}
throw new Exception("Invalid activity");
}
void ConfigureDecisionExpression(ModelItem mi)
{
var condition = mi;
var expression = condition.Properties[GlobalConstants.ExpressionPropertyText];
var ds = DataListConstants.DefaultStack;
if (expression?.Value != null)
{
var eval = Dev2DecisionStack.ExtractModelFromWorkflowPersistedData(expression.Value.ToString());
if (!string.IsNullOrEmpty(eval))
{
ExpressionText = eval;
}
}
else
{
var ser = new Dev2JsonSerializer();
ExpressionText = ser.Serialize(ds);
}
var displayName = mi.Properties[GlobalConstants.DisplayNamePropertyText];
if (displayName?.Value != null)
{
ds.DisplayText = displayName.Value.ToString();
}
Tos = ToObservableCollection();
}
public void ActivityHelper_InjectExpression_Dev2SwitchIsNull_ReturnNull()
{
//---------------Set up test pack-------------------
var viewModel = new DecisionDesignerViewModel(CreateModelItem());
var dev2DecisionStack = new Dev2DecisionStack()
{
DisplayText = "",
FalseArmText = "",
TrueArmText = "",
Version = "2",
Mode = Dev2DecisionMode.AND
};
dev2DecisionStack.TheStack = new List <Dev2Decision>();
var decisionExpressionMessage = new ConfigureDecisionExpressionMessage();
viewModel.Handle(decisionExpressionMessage);
var mySwitch = new Dev2Switch();
mySwitch = null;
var expressionText1 = string.Join("", GlobalConstants.InjectedSwitchDataFetch,
"(\"", "aaaaaaa", "\",",
GlobalConstants.InjectedDecisionDataListVariable,
")");
var expressionText = viewModel.ModelItem.Properties[expressionText1];
//------------Setup for test--------------------------
var expr = ActivityHelper.InjectExpression(mySwitch, expressionText);
Assert.IsNull(expr);
}
/// <summary>
/// Configures the decision expression.
/// Travis.Frisinger - Developed for new Decision Wizard
/// </summary>
void ConfigureDecisionExpression(ConfigureDecisionExpressionMessage args)
{
var condition = ConfigureActivity <DsfFlowDecisionActivity>(args.ModelItem, GlobalConstants.ConditionPropertyText, args.IsNew);
if (condition == null)
{
return;
}
var expression = condition.Properties[GlobalConstants.ExpressionPropertyText];
var ds = DataListConstants.DefaultStack;
if (expression != null && expression.Value != null)
{
//we got a model, push it in to the Model region ;)
// but first, strip and extract the model data ;)
var eval = Dev2DecisionStack.ExtractModelFromWorkflowPersistedData(expression.Value.ToString());
if (!string.IsNullOrEmpty(eval))
{
ds = JsonConvert.DeserializeObject <Dev2DecisionStack>(eval);
}
}
var displayName = args.ModelItem.Properties[GlobalConstants.DisplayNamePropertyText];
if (displayName != null && displayName.Value != null)
{
ds.DisplayText = displayName.Value.ToString();
}
var val = JsonConvert.SerializeObject(ds);
// Now invoke the Wizard ;)
_callBackHandler = StartDecisionWizard(args.EnvironmentModel, val);
// Wizard finished...
try
{
string tmp = WebHelper.CleanModelData(_callBackHandler);
var dds = JsonConvert.DeserializeObject <Dev2DecisionStack>(tmp);
if (dds == null)
{
return;
}
ActivityHelper.SetArmTextDefaults(dds);
ActivityHelper.InjectExpression(dds, expression);
ActivityHelper.SetArmText(args.ModelItem, dds);
ActivityHelper.SetDisplayName(args.ModelItem, dds); // PBI 9220 - 2013.04.29 - TWR
}
catch
{
_popupController.Show(GlobalConstants.DecisionWizardErrorString,
GlobalConstants.DecisionWizardErrorHeading, MessageBoxButton.OK,
MessageBoxImage.Error, null);
}
}
public void DecisionWithQuotesInDataExpectedNoUnhandledExceptions()
{
Dev2DecisionStack dds = new Dev2DecisionStack {
TheStack = new List <Dev2Decision>(), Mode = Dev2DecisionMode.AND
};
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
dds.AddModelItem(new Dev2Decision {
Col1 = "[[var]]", Col2 = "[[var]]", EvaluationFn = enDecisionType.IsEqual
});
string modelData = dds.ToVBPersistableModel();
CurrentDl = "<ADL><var/></ADL>";
TestData = "<root><var>\"something \"data\" \"</var></root>";
ErrorResultTO errors;
Guid exeID = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), new StringBuilder(TestData), new StringBuilder(CurrentDl), out errors);
IList <string> getDatalistID = new List <string> {
exeID.ToString()
};
var res = new Dev2DataListDecisionHandler().ExecuteDecisionStack(modelData, getDatalistID);
// remove test datalist ;)
DataListRemoval(exeID);
Assert.IsTrue(res);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
var decisionActivity = new DsfFlowDecisionActivity();
scenarioContext.TryGetValue("mode", out Dev2DecisionMode mode);
var decisionModels =
scenarioContext.Get <List <Tuple <string, enDecisionType, string, string> > >("decisionModels");
var dds = new Dev2DecisionStack {
TheStack = new List <Dev2Decision>(), Mode = mode, TrueArmText = "YES", FalseArmText = "NO"
};
foreach (var dm in decisionModels)
{
var dev2Decision = new Dev2Decision
{
Col1 = dm.Item1 ?? string.Empty,
EvaluationFn = dm.Item2,
Col2 = dm.Item3 ?? string.Empty,
Col3 = dm.Item4 ?? string.Empty
};
dds.AddModelItem(dev2Decision);
}
var modelData = dds.ToVBPersistableModel();
scenarioContext.Add("modelData", modelData);
decisionActivity.ExpressionText = string.Join("", GlobalConstants.InjectedDecisionHandler, "(\"", modelData,
"\",", GlobalConstants.InjectedDecisionDataListVariable, ")");
scenarioContext.TryGetValue("variableList", out List <Tuple <string, string> > variableList);
if (variableList == null)
{
variableList = new List <Tuple <string, string> >();
scenarioContext.Add("variableList", variableList);
}
var multiAssign = new DsfMultiAssignActivity();
var row = 1;
foreach (var variable in variableList)
{
multiAssign.FieldsCollection.Add(new ActivityDTO(variable.Item1, variable.Item2, row, true));
row++;
}
var x = new FlowDecision();
x.Condition = decisionActivity;
TestStartNode = new FlowStep
{
Action = multiAssign,
Next = x
};
scenarioContext.Add("activity", decisionActivity);
}
List <DebugItem> CreateDebugInputs(IExecutionEnvironment env)
{
List <IDebugItem> result = new List <IDebugItem>();
var allErrors = new ErrorResultTO();
try
{
Dev2DecisionStack dds = Conditions;
ErrorResultTO error;
string userModel = dds.GenerateUserFriendlyModel(env, dds.Mode, out error);
allErrors.MergeErrors(error);
foreach (Dev2Decision dev2Decision in dds.TheStack)
{
AddInputDebugItemResultsAfterEvaluate(result, ref userModel, env, dev2Decision.Col1, out error);
allErrors.MergeErrors(error);
AddInputDebugItemResultsAfterEvaluate(result, ref userModel, env, dev2Decision.Col2, out error);
allErrors.MergeErrors(error);
AddInputDebugItemResultsAfterEvaluate(result, ref userModel, env, dev2Decision.Col3, out error);
allErrors.MergeErrors(error);
}
var itemToAdd = new DebugItem();
userModel = userModel.Replace("OR", " OR\r\n")
.Replace("AND", " AND\r\n")
.Replace("\r\n ", "\r\n")
.Replace("\r\n\r\n", "\r\n")
.Replace(" ", " ");
AddDebugItem(new DebugItemStaticDataParams(userModel, "Statement"), itemToAdd);
result.Add(itemToAdd);
itemToAdd = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams(dds.Mode == Dev2DecisionMode.AND ? "YES" : "NO", "Require all decisions to be true"), itemToAdd);
result.Add(itemToAdd);
}
catch (JsonSerializationException)
{
}
catch (Exception e)
{
allErrors.AddError(e.Message);
}
finally
{
if (allErrors.HasErrors())
{
var serviceName = GetType().Name;
DisplayAndWriteError(serviceName, allErrors);
}
}
var val = result.Select(a => a as DebugItem).ToList();
_inner?.SetDebugInputs(val);
return(val);
}
public void Workflow_WorkflowNodesForHtml_FlowDecision_HandlingNestedObjects_With_NoFalseArm_ShouldSuccess()
{
var dev2DecisionStack = new Dev2DecisionStack
{
TheStack = new List <Dev2Decision>
{
new Dev2Decision
{
Cols1 = new List <DataStorage.WarewolfAtom>
{
DataStorage.WarewolfAtom.NewDataString("a")
}
},
new Dev2Decision
{
Cols1 = new List <DataStorage.WarewolfAtom>
{
DataStorage.WarewolfAtom.NewDataString("a")
}
}
},
DisplayText = "a",
FalseArmText = "ErrorArm",
TrueArmText = "true Arm",
Version = "2",
Mode = Dev2DecisionMode.AND
};
var jsonSerializer = new Dev2JsonSerializer();
var flowDecisionActivity = new DsfFlowDecisionActivity
{
ExpressionText = jsonSerializer.Serialize(dev2DecisionStack)
};
var flowNodes = new Collection <FlowNode>
{
new FlowDecision(flowDecisionActivity)
{
DisplayName = "Decision (sdf)",
True = new FlowStep {
Action = new DsfMultiAssignActivity {
DisplayName = "Assign (success)"
}
},
}
};
var sut = new Workflow(flowNodes);
var nodes = sut.WorkflowNodesForHtml;
Assert.AreEqual(1, nodes.Count);
Assert.AreEqual(1, nodes[0].NextNodes.Count);
Assert.AreEqual(2, sut.WorkflowNodes.Count);
}
internal static string CleanModelData(Dev2DecisionCallbackHandler callBackHandler)
{
// Remove naughty chars...
string tmp = callBackHandler.ModelData;
// remove the silly Choose... from the string
tmp = Dev2DecisionStack.RemoveDummyOptionsFromModel(tmp.ToStringBuilder());
// remove [[]], &, !
tmp = Dev2DecisionStack.RemoveNaughtyCharsFromModel(tmp);
return(tmp);
}
public static void SetArmTextDefaults(Dev2DecisionStack dds)
{
if (String.IsNullOrEmpty(dds.TrueArmText.Trim()))
{
dds.TrueArmText = GlobalConstants.DefaultTrueArmText;
}
if (String.IsNullOrEmpty(dds.FalseArmText.Trim()))
{
dds.FalseArmText = GlobalConstants.DefaultFalseArmText;
}
}
public void Mode_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var dev2DecisionStack = new Dev2DecisionStack()
{
Mode = Dev2DecisionMode.AND
};
var dev2DecisionStack1 = new Dev2DecisionStack()
{
Mode = Dev2DecisionMode.OR
};
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
var dsfCalculateActivity = new DsfCalculateActivity();
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
var trueArms = new List <IDev2Activity>
{
dsfBaseConvertActivity,
dsfCalculateActivity,
dsfCaseConvertActivity
};
var trueArms1 = new List <IDev2Activity>
{
dsfBaseConvertActivity,
dsfCalculateActivity,
dsfCaseConvertActivity
};
var uniqueId = Guid.NewGuid().ToString();
var decision = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a",
FalseArm = trueArms,
Conditions = dev2DecisionStack
};
var decision1 = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a",
FalseArm = trueArms1,
Conditions = dev2DecisionStack1
};
//---------------Assert Precondition----------------
Assert.IsNotNull(decision);
//---------------Execute Test ----------------------
var equals = decision.Equals(decision1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
private static string GetResultString(string theResult, Dev2DecisionStack dds)
{
var resultString = theResult;
if (theResult == "True")
{
resultString = dds.TrueArmText;
}
else if (theResult == "False")
{
resultString = dds.FalseArmText;
}
return(resultString);
}
public void ConflictModelFactory_GivenDsfSwitchConflictNode_ShouldReturnMergeToolModel()
{
//------------Setup for test--------------------------
var adapter = new Mock <IApplicationAdaptor>();
adapter.Setup(p => p.TryFindResource(It.IsAny <object>())).Returns(new object());
CustomContainer.Register(adapter.Object);
var node = new Mock <IConflictTreeNode>();
var contextualResource = new Mock <IContextualResourceModel>();
var dev2DecisionStack = new Dev2DecisionStack
{
TheStack = new List <Dev2Decision>(),
TrueArmText = "a",
FalseArmText = "a",
DisplayText = "a",
Mode = Dev2DecisionMode.AND
};
var serializer = new Dev2JsonSerializer();
var serialize = serializer.Serialize(dev2DecisionStack);
var condition = new DsfFlowSwitchActivity
{
ExpressionText = serialize
};
var value = new DsfSwitch(condition)
{
Switch = "bbb",
Switches = new Dictionary <string, IDev2Activity>
{
{ "a", new DsfCalculateActivity() },
{ "b", new DsfCalculateActivity() }
}
};
var assignStep = new FlowStep
{
Action = value
};
node.Setup(p => p.Activity).Returns(value);
var toolConflictItem = new ToolConflictItem(new ViewModels.Merge.Utils.ConflictRowList(new Mock <IConflictModelFactory>().Object, new Mock <IConflictModelFactory>().Object, new List <ConflictTreeNode>(), new List <ConflictTreeNode>()), ViewModels.Merge.Utils.ConflictRowList.Column.Current);
//------------Execute Test---------------------------
var completeConflict = new ConflictModelFactory(toolConflictItem, contextualResource.Object, node.Object);
//------------Assert Results-------------------------
Assert.IsNotNull(completeConflict);
var mergeToolModel = completeConflict.CreateModelItem(toolConflictItem, node.Object);
Assert.AreEqual("bbb", mergeToolModel.MergeDescription);
Assert.AreEqual(typeof(SwitchDesignerViewModel).FullName, ((ToolConflictItem)mergeToolModel).ActivityDesignerViewModel.GetType().FullName);
}
private Guid generateGuid()
{
IDataListCompiler testCompiler = DataListFactory.CreateDataListCompiler();
var stack = new Dev2DecisionStack();
stack.TheStack = new List <Dev2Decision> {
new Dev2Decision()
};
var error = new ErrorResultTO();
Guid MyModel = testCompiler.PushSystemModelToDataList(stack, out error);
return(MyModel);
}
public static void InjectExpression(Dev2DecisionStack ds, ModelProperty activityExpression)
{
if (ds == null)
{
return;
}
string modelData = ds.ToVBPersistableModel();
string expressionToInject = String.Join("", GlobalConstants.InjectedDecisionHandler, "(\"",
modelData, "\",",
GlobalConstants.InjectedDecisionDataListVariable, ")");
if (activityExpression != null)
{
activityExpression.SetValue(expressionToInject);
}
}
public void FetchDecisionModel_Expected_EmptyJsonString()
{
var testWebModel = new WebModel();
IDev2DataModel testModel = new Dev2Decision();
var stack = new Dev2DecisionStack {
TheStack = new List <Dev2Decision> {
new Dev2Decision()
}
};
string expected = "{}";
string actual = testWebModel.FetchDecisionModel("", Guid.Empty, Guid.Empty);
Assert.AreEqual(expected, actual);
}
public static string ExtractData(string val)
{
if (val.IndexOf(GlobalConstants.InjectedSwitchDataFetch, StringComparison.Ordinal) >= 0)
{
var start = val.IndexOf("(", StringComparison.Ordinal);
if (start > 0)
{
var end = val.IndexOf(@""",AmbientData", StringComparison.Ordinal);
if (end > start)
{
start += 2;
val = val.Substring(start, end - start);
val = Dev2DecisionStack.FromVBPersitableModelToJSON(val);
}
}
}
return(val);
}
string FetchStackValue(Dev2DecisionStack stack, int stackIndex, int columnIndex)
{
// if out of bounds return an empty string ;)
if (stackIndex >= stack.TheStack.Count)
{
return(string.Empty);
}
if (columnIndex == 1)
{
return(stack.TheStack[stackIndex].Col1);
}
if (columnIndex == 2)
{
return(stack.TheStack[stackIndex].Col2);
}
return(string.Empty);
}
/// <summary>
/// Saves the JSON model for decisions from the wizard ;)
/// </summary>
/// <param name="args">The args.</param>
/// <param name="workspaceId">The workspace ID.</param>
/// <param name="dataListId">The data list ID.</param>
/// <returns></returns>
public string SaveModel(string args, Guid workspaceId, Guid dataListId)
{
string result = "{ \"message\" : \"Error Saving Model\"} ";
if (dataListId != GlobalConstants.NullDataListID)
{
var compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO errors;
// remove the silly Choose... from the string
args = Dev2DecisionStack.RemoveDummyOptionsFromModel(new StringBuilder(args));
// remove [[]], &, !
args = Dev2DecisionStack.RemoveNaughtyCharsFromModel(args);
compiler.UpsertSystemTag(dataListId, enSystemTag.SystemModel, args, out errors);
result = "{ \"message\" : \"Saved Model\"} ";
}
return(result);
}
public static void SetupForSystem()
{
Utils.SetupResourceDictionaryActivities();
var tos = new List <DecisionTO>();
FeatureContext.Current["Tos"] = tos;
var stack = new Dev2DecisionStack();
var mi = CreateModelItem(tos);
FeatureContext.Current["modelItem"] = mi;
var mockView = new Mock <IView>();
FeatureContext.Current.Add("view", mockView.Object);
var vm = new DecisionDesignerViewModel(mi);
FeatureContext.Current["viewModel"] = vm;
var dataContext = vm;
mockView.SetupGet(view => view.DataContext).Returns(dataContext);
Utils.ShowTheViewForTesting(mockView.Object);
}
public static string ExtractData(string val)
{
if (val.IndexOf(GlobalConstants.InjectedSwitchDataFetch, StringComparison.Ordinal) >= 0)
{
// Time to extract the data
int start = val.IndexOf("(", StringComparison.Ordinal);
if (start > 0)
{
int end = val.IndexOf(@""",AmbientData", StringComparison.Ordinal);
if (end > start)
{
start += 2;
val = val.Substring(start, (end - start));
// Convert back for usage ;)
val = Dev2DecisionStack.FromVBPersitableModelToJSON(val);
}
}
}
return(val);
}
// Travis.Frisinger - 28.01.2013 : Amended for Debug
public override List <DebugItem> GetDebugOutputs(IExecutionEnvironment dataList)
{
if (_debugOutputs != null && _debugOutputs.Count > 0)
{
return(_debugOutputs);
}
var result = new List <DebugItem>();
string resultString = _theResult.ToString();
DebugItem itemToAdd = new DebugItem();
IDataListCompiler c = DataListFactory.CreateDataListCompiler();
var val = new StringBuilder(Dev2DecisionStack.ExtractModelFromWorkflowPersistedData(ExpressionText));
try
{
Dev2DecisionStack dds = c.ConvertFromJsonToModel <Dev2DecisionStack>(val);
if (_theResult.ToString() == "True")
{
resultString = dds.TrueArmText;
}
else if (_theResult.ToString() == "False")
{
resultString = dds.FalseArmText;
}
itemToAdd.AddRange(new DebugItemStaticDataParams(resultString, "").GetDebugItemResult());
result.Add(itemToAdd);
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception)
// ReSharper restore EmptyGeneralCatchClause
{
itemToAdd.AddRange(new DebugItemStaticDataParams(resultString, "").GetDebugItemResult());
result.Add(itemToAdd);
}
return(result);
}
public void ActivityHelper_Dev2Decision_Null_TrueArmText_SetArmText()
{
//---------------Set up test pack-------------------
using (var viewModel = new DecisionDesignerViewModel(CreateModelItem()))
{
var dev2DecisionStack = new Dev2DecisionStack
{
DisplayText = "",
FalseArmText = "",
TrueArmText = null,
Version = "2",
Mode = Dev2DecisionMode.AND,
TheStack = new List <Dev2Decision>()
};
var decisionExpressionMessage = new ConfigureDecisionExpressionMessage();
viewModel.Handle(decisionExpressionMessage);
//------------Setup for test--------------------------
ActivityHelper.SetArmTextDefaults(dev2DecisionStack);
Assert.AreEqual("True", dev2DecisionStack.TrueArmText);
}
}
IEnumerable <IDev2Activity> ParseDecision(FlowDecision decision, List <IDev2Activity> seenActivities)
{
var activity = decision.Condition as DsfFlowDecisionActivity;
if (activity != null)
{
if (seenActivities.Contains(activity))
{
return(new List <IDev2Activity> {
activity
});
}
var rawText = activity.ExpressionText;
// ReSharper disable MaximumChainedReferences
var activityTextjson = rawText.Substring(rawText.IndexOf("{", StringComparison.Ordinal)).Replace(@""",AmbientDataList)", "").Replace("\"", "!");
// ReSharper restore MaximumChainedReferences
var activityText = Dev2DecisionStack.FromVBPersitableModelToJSON(activityTextjson);
var decisionStack = JsonConvert.DeserializeObject <Dev2DecisionStack>(activityText);
var dec = new DsfDecision(activity);
if (!seenActivities.Contains(activity))
{
seenActivities.Add(dec);
}
dec.TrueArm = ParseTools(decision.True, seenActivities);
dec.FalseArm = ParseTools(decision.False, seenActivities);
dec.Conditions = decisionStack;
dec.And = decisionStack.Mode == Dev2DecisionMode.AND;
return(new List <IDev2Activity>
{
dec
});
}
throw new Exception("Invalid activity");
}
public void DsfDecision_GetState_ReturnsStateVariable()
{
//---------------Set up test pack-------------------
var conditions = new Dev2DecisionStack();
conditions.TheStack = new List <Dev2Decision>();
conditions.AddModelItem(new Dev2Decision
{
Col1 = "[[a]]",
EvaluationFn = Data.Decisions.Operations.enDecisionType.IsEqual,
Col2 = "bob"
});
var serializer = new Dev2JsonSerializer();
//------------Setup for test--------------------------
var act = new DsfDecision {
Conditions = conditions, And = true
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
Assert.AreEqual(5, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "Conditions",
Type = StateVariable.StateType.Input,
Value = serializer.Serialize(conditions)
},
new StateVariable
{
Name = "And",
Type = StateVariable.StateType.Input,
Value = "True"
},
new StateVariable
{
Name = "Result",
Type = StateVariable.StateType.Output,
Value = null
},
new StateVariable
{
Name = "TrueArm",
Type = StateVariable.StateType.Output,
Value = ActivityHelper.GetSerializedStateValueFromCollection(act.TrueArm?.ToList())
},
new StateVariable
{
Name = "FalseArm",
Type = StateVariable.StateType.Output,
Value = ActivityHelper.GetSerializedStateValueFromCollection(act.FalseArm?.ToList())
}
};
var iter = act.GetState().Select(
(item, index) => new
{
value = item,
expectValue = expectedResults[index]
}
);
//------------Assert Results-------------------------
foreach (var entry in iter)
{
Assert.AreEqual(entry.expectValue.Name, entry.value.Name);
Assert.AreEqual(entry.expectValue.Type, entry.value.Type);
Assert.AreEqual(entry.expectValue.Value, entry.value.Value);
}
}
public void Workflow_Given_WorkflowNodesForHtml_Executed_WorkflowNodes_FlowDecision_HandlingNestedObjects_ShouldReturnAllNodes()
{
var dev2DecisionStack = new Dev2DecisionStack
{
TheStack = new List <Dev2Decision>
{
new Dev2Decision
{
Cols1 = new List <DataStorage.WarewolfAtom>
{
DataStorage.WarewolfAtom.NewDataString("a")
}
},
new Dev2Decision
{
Cols1 = new List <DataStorage.WarewolfAtom>
{
DataStorage.WarewolfAtom.NewDataString("a")
}
}
},
DisplayText = "a",
FalseArmText = "ErrorArm",
TrueArmText = "true Arm",
Version = "2",
Mode = Dev2DecisionMode.AND
};
var jsonSerializer = new Dev2JsonSerializer();
var flowDecisionActivity = new DsfFlowDecisionActivity
{
ExpressionText = jsonSerializer.Serialize(dev2DecisionStack)
};
var flowNodes = new Collection <FlowNode>
{
new FlowDecision(flowDecisionActivity)
{
DisplayName = "Decision (sdf)",
True = new FlowStep {
Action = new DsfMultiAssignActivity {
DisplayName = "Assign (success)"
}
},
False = new FlowStep {
Action = new DsfMultiAssignActivity
{
DisplayName = "Assign (fail)",
NextNodes = new List <IDev2Activity>
{
new DsfCommentActivity {
DisplayName = "Comment (this activity should not be part of the coverage)"
},
new DsfMultiAssignActivity {
DisplayName = "Assign (child node)"
}
}
}
}
}
};
var sut = new Workflow(flowNodes);
var nodes = sut.WorkflowNodesForHtml;
Assert.AreEqual(1, nodes.Count);
Assert.AreEqual(2, nodes[0].NextNodes.Count);
Assert.AreEqual(3, sut.WorkflowNodes.Count);
}
// Travis.Frisinger - 28.01.2013 : Amended for Debug
public override List <DebugItem> GetDebugInputs(IExecutionEnvironment env, int update)
{
if (_debugInputs != null && _debugInputs.Count > 0)
{
return(_debugInputs);
}
List <IDebugItem> result = new List <IDebugItem>();
var allErrors = new ErrorResultTO();
var val = new StringBuilder(Dev2DecisionStack.ExtractModelFromWorkflowPersistedData(ExpressionText));
try
{
Dev2DecisionStack dds = DataListUtil.ConvertFromJsonToModel <Dev2DecisionStack>(val);
ErrorResultTO error;
string userModel = dds.GenerateUserFriendlyModel(env, dds.Mode, out error);
allErrors.MergeErrors(error);
foreach (Dev2Decision dev2Decision in dds.TheStack)
{
AddInputDebugItemResultsAfterEvaluate(result, ref userModel, env, dds.Mode, dev2Decision.Col1, out error);
allErrors.MergeErrors(error);
AddInputDebugItemResultsAfterEvaluate(result, ref userModel, env, dds.Mode, dev2Decision.Col2, out error);
allErrors.MergeErrors(error);
AddInputDebugItemResultsAfterEvaluate(result, ref userModel, env, dds.Mode, dev2Decision.Col3, out error);
allErrors.MergeErrors(error);
}
var itemToAdd = new DebugItem();
userModel = userModel.Replace("OR", " OR\r\n")
.Replace("AND", " AND\r\n")
.Replace("\r\n ", "\r\n")
.Replace("\r\n\r\n", "\r\n")
.Replace(" ", " ");
AddDebugItem(new DebugItemStaticDataParams(userModel, "Statement"), itemToAdd);
result.Add(itemToAdd);
itemToAdd = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams(dds.Mode == Dev2DecisionMode.AND ? "YES" : "NO", "Require All decisions to be True"), itemToAdd);
result.Add(itemToAdd);
}
catch (JsonSerializationException)
{
Dev2Switch ds = new Dev2Switch {
SwitchVariable = val.ToString()
};
DebugItem itemToAdd = new DebugItem();
var a = env.Eval(ds.SwitchVariable, 0);
var debugResult = new DebugItemWarewolfAtomResult(ExecutionEnvironment.WarewolfEvalResultToString(a), "", ds.SwitchVariable, "", "Switch on", "", "=");
itemToAdd.AddRange(debugResult.GetDebugItemResult());
result.Add(itemToAdd);
}
catch (Exception e)
{
allErrors.AddError(e.Message);
}
finally
{
if (allErrors.HasErrors())
{
var serviceName = GetType().Name;
DisplayAndWriteError(serviceName, allErrors);
}
}
return(result.Select(a => a as DebugItem).ToList());
}
Dev2DecisionStack ResolveAllRecords(IExecutionEnvironment env, Dev2DecisionStack stack, Dev2Decision decision, bool[] effectedCols, out ErrorResultTO errors, int update)
{
if (effectedCols == null)
{
throw new ArgumentNullException("effectedCols");
}
var stackIndex = stack.TheStack.IndexOf(decision);
stack.TheStack.Remove(decision);
errors = new ErrorResultTO();
if (effectedCols[0])
{
var data = env.EvalAsListOfStrings(decision.Col1, update);
var reStackIndex = stackIndex;
foreach (var item in data)
{
var newDecision = new Dev2Decision {
Col1 = item, Col2 = decision.Col2, Col3 = decision.Col3, EvaluationFn = decision.EvaluationFn
};
stack.TheStack.Insert(reStackIndex++, newDecision);
}
}
if (effectedCols[1])
{
var data = env.EvalAsListOfStrings(decision.Col2, update);
var reStackIndex = stackIndex;
foreach (var item in data)
{
var newDecision = new Dev2Decision {
Col1 = FetchStackValue(stack, reStackIndex, 1), Col2 = item, Col3 = decision.Col3, EvaluationFn = decision.EvaluationFn
};
if (effectedCols[0])
{
// ensure we have the correct indexing ;)
if (reStackIndex < stack.TheStack.Count)
{
stack.TheStack[reStackIndex++] = newDecision;
}
else
{
stack.TheStack.Insert(reStackIndex++, newDecision);
}
}
else
{
stack.TheStack.Insert(reStackIndex++, newDecision);
}
}
}
if (effectedCols[2])
{
var data = env.EvalAsListOfStrings(decision.Col3, update);
var reStackIndex = stackIndex;
foreach (var item in data)
{
var newDecision = new Dev2Decision {
Col1 = FetchStackValue(stack, reStackIndex, 1), Col2 = FetchStackValue(stack, reStackIndex, 2), Col3 = item, EvaluationFn = decision.EvaluationFn
};
if (effectedCols[0] || effectedCols[1])
{
// ensure we have the correct indexing ;)
if (reStackIndex < stack.TheStack.Count)
{
stack.TheStack[reStackIndex++] = newDecision;
}
else
{
stack.TheStack.Insert(reStackIndex++, newDecision);
}
}
else
{
stack.TheStack.Insert(reStackIndex++, newDecision);
}
}
}
return(stack);
}
