void Debug(IDSFDataObject dataObject, string firstOrDefault, Dev2Switch ds)
{
try
{
if (dataObject.IsDebugMode())
{
List <DebugItem> result = new List <DebugItem>();
DebugItem itemToAdd = new DebugItem();
var debugResult = new DebugItemWarewolfAtomResult(firstOrDefault, "", ds.SwitchVariable, "", "Switch on", "", "=");
itemToAdd.AddRange(debugResult.GetDebugItemResult());
result.Add(itemToAdd);
_debugInputs = result;
DispatchDebugState(dataObject, StateType.Before);
DispatchDebugState(dataObject, StateType.After);
if (_inner != null)
{
_inner.SetDebugInputs(_debugInputs);
}
}
}
// ReSharper disable EmptyGeneralCatchClause
catch
// ReSharper restore EmptyGeneralCatchClause
{
}
}
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");
}
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);
}
public void Debug_GivenDataObject_ShouldSetInnerBugOuputs_IncrementsDebugInputs()
{
//---------------Set up test pack-------------------
//string displayName, IDebugDispatcher debugDispatcher, bool isAsync = false
var switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString(),
ExpressionText = ""
};
var activity = new DsfSwitch(switchActivity)
{
Result = "[[MyResult]]"
};
var dataObject = new Mock <IDSFDataObject>();
dataObject.Setup(o => o.IsDebugMode()).Returns(true);
var obj = new Warewolf.Testing.PrivateObject(activity);
//---------------Assert Precondition----------------
var getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(0, getDebugInputs.Count);
//---------------Execute Test ----------------------
var result = "[[variable]]";
var mySwitch = new Dev2Switch();
obj.Invoke("Debug", dataObject.Object, result, mySwitch);
//---------------Test Result -----------------------
getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(1, getDebugInputs.Count);
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_debugOutputs.Clear();
_debugInputs.Clear();
NextNodes = new List <IDev2Activity>();
try
{
var ds = new Dev2Switch {
SwitchVariable = Switch
};
var firstOrDefault = dataObject.Environment.EvalAsListOfStrings(ds.SwitchVariable, update).FirstOrDefault();
if (dataObject.IsDebugMode())
{
InitializeDebug(dataObject);
Debug(dataObject, firstOrDefault, ds);
DispatchDebugState(dataObject, StateType.Before, update);
}
if (firstOrDefault != null)
{
NewNextNodes(dataObject, firstOrDefault);
}
}
catch (Exception err)
{
dataObject.Environment.Errors.Add(err.Message);
}
finally
{
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.After, update);
_debugOutputs = new List <DebugItem>();
}
}
}
public void ActivityHelper_WithKeyProperty_SetSwitchKeyProperty_Dev2Switch()
{
var uniqueId = Guid.NewGuid().ToString();
var calcActivity = new DsfCalculateActivity {
UniqueID = uniqueId
};
var flowStep = new FlowStep {
Action = calcActivity
};
//---------------Set up test pack-------------------
using (var viewModel = new SwitchDesignerViewModel(CreateSwitchModelItem(flowStep), "Switch"))
{
var mySwitch = new Dev2Switch
{
SwitchExpression = "[[a]]"
};
var parentNodeProperty = viewModel.ModelItem.Properties["Cases"].Dictionary;
//------------Setup for test--------------------------
var switchCaseFirst = ModelItemUtils.CreateModelItem(parentNodeProperty.First());
var switchCaseLast = ModelItemUtils.CreateModelItem(parentNodeProperty.Last());
ActivityHelper.SetSwitchKeyProperty(mySwitch, switchCaseFirst);
var modelItemFirst = switchCaseFirst.Properties["Value"].Value.Properties["Action"].Value;
var modelItemLast = switchCaseLast.Properties["Value"].Value.Properties["Action"].Value;
Assert.AreEqual(uniqueId, modelItemFirst.Properties["UniqueID"].ComputedValue);
Assert.IsNull(modelItemLast);
}
}
public override IDev2Activity Execute(IDSFDataObject dataObject, int update)
{
_debugOutputs.Clear();
_debugInputs.Clear();
try
{
Dev2Switch ds = new Dev2Switch {
SwitchVariable = Switch
};
var firstOrDefault = dataObject.Environment.EvalAsListOfStrings(ds.SwitchVariable, update).FirstOrDefault();
Debug(dataObject, firstOrDefault, ds);
if (firstOrDefault != null)
{
var a = firstOrDefault;
if (Switches.ContainsKey(a))
{
return(Switches[a]);
}
if (Default != null)
{
var activity = Default.FirstOrDefault();
return(activity);
}
}
}
catch (Exception err)
{
dataObject.Environment.Errors.Add(err.Message);
}
return(null);
}
public void ConfigureSwitchExpression(ConfigureSwitchExpressionMessage args)
{
var expression = ConfigureActivity <DsfFlowSwitchActivity>(args.ModelItem, GlobalConstants.SwitchExpressionPropertyText, args.IsNew);
if (expression == null)
{
return;
}
var expressionText = expression.Properties[GlobalConstants.SwitchExpressionTextPropertyText];
Dev2Switch ds;
if (expressionText != null && expressionText.Value != null)
{
ds = new Dev2Switch();
var val = ActivityHelper.ExtractData(expressionText.Value.ToString());
if (!string.IsNullOrEmpty(val))
{
ds.SwitchVariable = val;
}
}
else
{
ds = DataListConstants.DefaultSwitch;
}
var displayName = args.ModelItem.Properties[GlobalConstants.DisplayNamePropertyText];
if (displayName != null && displayName.Value != null)
{
ds.DisplayText = displayName.Value.ToString();
}
var webModel = JsonConvert.SerializeObject(ds);
// now invoke the wizard ;)
_callBackHandler = StartSwitchDropWizard(args.EnvironmentModel, webModel);
// Wizard finished...
// Now Fetch from DL and push the model data into the workflow
try
{
var resultSwitch = JsonConvert.DeserializeObject <Dev2Switch>(_callBackHandler.ModelData);
ActivityHelper.InjectExpression(resultSwitch, expressionText);
// PBI 9220 - 2013.04.29 - TWR
ActivityHelper.SetDisplayName(args.ModelItem, resultSwitch); // MUST use args.ModelItem otherwise it won't be visible!
}
catch
{
_popupController.Show(GlobalConstants.SwitchWizardErrorString,
GlobalConstants.SwitchWizardErrorHeading, MessageBoxButton.OK,
MessageBoxImage.Error, null);
}
}
public static void SetSwitchKeyProperty(Dev2Switch ds, ModelItem switchCase)
{
if (ds != null)
{
ModelProperty keyProperty = switchCase.Properties["Key"];
if (keyProperty != null)
{
keyProperty.SetValue(ds.SwitchVariable);
}
}
}
public static void SetSwitchKeyProperty(Dev2Switch ds, ModelItem switchCase)
{
if (ds != null)
{
var keyProperty = switchCase.Properties["Key"];
if (keyProperty != null)
{
keyProperty.SetValue(ds.SwitchExpression);
}
}
}
private Guid generateGuidSwitch()
{
IDataListCompiler testCompiler = DataListFactory.CreateDataListCompiler();
var stack = new Dev2Switch()
{
SwitchVariable = ""
};
var error = new ErrorResultTO();
Guid MyModel = testCompiler.PushSystemModelToDataList(stack, out error);
return(MyModel);
}
public static string InjectExpression(Dev2Switch ds, ModelProperty activityExpression)
{
if (ds == null)
{
return(null);
}
var expressionToInject = String.Join("", GlobalConstants.InjectedSwitchDataFetch,
"(\"", ds.SwitchVariable, "\",",
GlobalConstants.InjectedDecisionDataListVariable,
")");
if (activityExpression != null)
{
activityExpression.SetValue(expressionToInject);
}
return(expressionToInject);
}
public void Dev2Switch_SetProperties_AreEqual_ExpectTrue()
{
//-----------------------Arrange--------------------
//-----------------------Act------------------------
var dev2Switch = new Dev2Switch()
{
SwitchVariable = "TestSwitchVariable",
SwitchExpression = "TestSwitchExpression",
DisplayText = "TestDisplayText"
};
//-----------------------Assert---------------------
Assert.AreEqual(Dev2ModelType.Dev2Switch, dev2Switch.ModelName);
Assert.AreEqual("TestSwitchVariable", dev2Switch.SwitchVariable);
Assert.AreEqual("TestSwitchExpression", dev2Switch.SwitchExpression);
Assert.AreEqual("TestDisplayText", dev2Switch.DisplayText);
}
void Initialize(string display)
{
var expressionText = ModelItem.Properties[GlobalConstants.SwitchExpressionTextPropertyText];
ModelProperty switchCaseValue = ModelItem.Properties["Case"];
Dev2Switch ds;
if (expressionText?.Value != null)
{
ds = new Dev2Switch();
var val = ActivityHelper.ExtractData(expressionText.Value.ToString());
if (!string.IsNullOrEmpty(val))
{
ds.SwitchVariable = val;
}
}
else
{
ds = DataListConstants.DefaultSwitch;
}
if (string.IsNullOrEmpty(display))
{
var displayName = ModelItem.Properties[GlobalConstants.DisplayNamePropertyText];
if (displayName?.Value != null)
{
ds.DisplayText = displayName.Value.ToString();
}
}
else
{
ds.DisplayText = display;
}
if (switchCaseValue != null)
{
string val = switchCaseValue.ComputedValue.ToString();
ds.SwitchExpression = val;
}
SwitchVariable = ds.SwitchVariable;
SwitchExpression = ds.SwitchExpression;
DisplayText = ds.DisplayText;
if (DisplayText != SwitchVariable && DisplayText != "Switch")
{
_hascustomeDisplayText = true;
}
}
protected override void ExecuteTool(IDSFDataObject dataObject)
{
_debugOutputs.Clear();
_debugInputs.Clear();
try
{
Dev2Switch ds = new Dev2Switch {
SwitchVariable = Switch
};
var firstOrDefault = dataObject.Environment.EvalAsListOfStrings(ds.SwitchVariable).FirstOrDefault();
Debug(dataObject, firstOrDefault, ds);
if (firstOrDefault != null)
{
var a = firstOrDefault;
if (Switches.ContainsKey(a))
{
Switches[a].Execute(dataObject);
}
else
{
if (Default != null)
{
var activity = Default.FirstOrDefault();
if (activity != null)
{
activity.Execute(dataObject);
}
}
}
}
}
catch (Exception err)
{
dataObject.Environment.Errors.Add(err.Message);
}
finally
{
}
}
void Debug(IDSFDataObject dataObject, string firstOrDefault, Dev2Switch ds)
{
try
{
if (dataObject.IsDebugMode())
{
var result = new List <DebugItem>();
var itemToAdd = new DebugItem();
var debugResult = new DebugItemWarewolfAtomResult(firstOrDefault, "", ds.SwitchVariable, "", "Switch on", "", "=");
itemToAdd.AddRange(debugResult.GetDebugItemResult());
result.Add(itemToAdd);
_debugInputs = result;
if (Inner != null)
{
Inner.SetDebugInputs(_debugInputs);
}
}
}
catch (Exception e)
{
Dev2Logger.Warn(e.Message, GlobalConstants.WarewolfWarn);
}
}
// 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());
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_debugOutputs.Clear();
_debugInputs.Clear();
var startTime = DateTime.Now;
try
{
Dev2Switch ds = new Dev2Switch {
SwitchVariable = Switch
};
var firstOrDefault = dataObject.Environment.EvalAsListOfStrings(ds.SwitchVariable, update).FirstOrDefault();
if (dataObject.IsDebugMode())
{
InitializeDebug(dataObject);
Debug(dataObject, firstOrDefault, ds);
DispatchDebugState(dataObject, StateType.Before, update);
}
if (firstOrDefault != null)
{
var a = firstOrDefault;
if (Switches.ContainsKey(a))
{
Result = a;
if (dataObject.IsDebugMode())
{
DebugOutput(dataObject);
}
NextNodes = new List <IDev2Activity> {
Switches[a]
};
}
else
{
if (Default != null)
{
Result = "Default";
var activity = Default.FirstOrDefault();
if (dataObject.IsDebugMode())
{
DebugOutput(dataObject);
}
NextNodes = new List <IDev2Activity> {
activity
};
}
}
}
}
catch (Exception err)
{
dataObject.Environment.Errors.Add(err.Message);
}
finally
{
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.After, update);
_debugOutputs = new List <DebugItem>();
}
}
}
public void ActivityHelper_InjectExpression_Dev2Switch()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
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();
//------------Setup for test--------------------------
var testAct = new DsfFlowSwitchActivity {
ExpressionText = ""
};
var prop = new Mock <ModelProperty>();
prop.Setup(p => p.ComputedValue).Returns(testAct);
ActivityHelper.InjectExpression(mySwitch, prop.Object);
//------------Assert Results-------------------------
var act = new DsfDecision {
Conditions = dev2DecisionStack, And = true
};
var stateItems = act.GetState();
Assert.AreEqual(5, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "Conditions",
Type = StateVariable.StateType.Input,
Value = serializer.Serialize(dev2DecisionStack)
},
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.AreEqual(expectedResults.Length, iter.Count());
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);
}
}
// Travis.Frisinger - 28.01.2013 : Amended for Debug
public override List <DebugItem> GetDebugInputs(IBinaryDataList dataList)
{
List <IDebugItem> result = new List <IDebugItem>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
var allErrors = new ErrorResultTO();
var val = new StringBuilder(Dev2DecisionStack.ExtractModelFromWorkflowPersistedData(ExpressionText));
try
{
Dev2DecisionStack dds = compiler.ConvertFromJsonToModel <Dev2DecisionStack>(val);
ErrorResultTO error;
string userModel = dds.GenerateUserFriendlyModel(dataList.UID, dds.Mode, out error);
allErrors.MergeErrors(error);
foreach (Dev2Decision dev2Decision in dds.TheStack)
{
AddInputDebugItemResultsAfterEvaluate(result, ref userModel, dataList, dds.Mode, dev2Decision.Col1, out error);
allErrors.MergeErrors(error);
AddInputDebugItemResultsAfterEvaluate(result, ref userModel, dataList, dds.Mode, dev2Decision.Col2, out error);
allErrors.MergeErrors(error);
AddInputDebugItemResultsAfterEvaluate(result, ref userModel, dataList, 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();
ErrorResultTO errors;
IBinaryDataListEntry expressionsEntry = compiler.Evaluate(dataList.UID, enActionType.User, ds.SwitchVariable, false, out errors);
var debugResult = new DebugItemVariableParams(ds.SwitchVariable, "Switch on", expressionsEntry, dataList.UID);
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);
ErrorResultTO error;
compiler.UpsertSystemTag(_dataListId, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out error);
}
}
return(result.Select(a => a as DebugItem).ToList());
}