public void SequenceDesignerViewModel_ActivityNames_When4_HasAllNames()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(4, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
}
public void DsfBaseConvert_UpdateForEachOutputs_WhenContainsMatchingStar_UpdateSuccessful()
{
//------------Setup for test--------------------------
List <BaseConvertTO> fieldsCollection = new List <BaseConvertTO>
{
new BaseConvertTO("[[rs(*).val]]", "text", "hex", "abc", 1)
};
var dsfBaseConvert = new DsfBaseConvertActivity {
ConvertCollection = fieldsCollection
};
//------------Execute Test---------------------------
dsfBaseConvert.UpdateForEachOutputs(new List <Tuple <string, string> >
{
new Tuple <string, string>("[[rs(*).val]]", "[[rs(1).val]]"),
}, null);
//------------Assert Results-------------------------
var collection = dsfBaseConvert.ConvertCollection;
Assert.AreEqual("[[rs(1).val]]", collection[0].ToExpression);
}
public void GetActivityFieldsOffBaseConvertActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfBaseConvertActivity baseConvertActivity = new DsfBaseConvertActivity { ConvertCollection = new List<BaseConvertTO> { new BaseConvertTO("[[FromExpression]]", "Text", "Binary", "[[ToExpression]]", 1), new BaseConvertTO("[[FromExpression2]]", "Text", "Binary", "[[ToExpression2]]", 2) } };
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
List<string> actual = strategy.GetActivityFields(baseConvertActivity);
List<string> expected = new List<string> { "[[FromExpression]]", "[[ToExpression]]", "[[FromExpression2]]", "[[ToExpression2]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void FalseArm_Different_Object_Is_Equal()
{
//---------------Set up test pack-------------------
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
var dsfCalculateActivity = new DsfCalculateActivity()
{
NextNodes = new List <IDev2Activity>()
{
dsfBaseConvertActivity
}
};
;
var dsfCaseConvertActivity = new DsfCaseConvertActivity()
{
NextNodes = new List <IDev2Activity>()
{
dsfCalculateActivity
}
};
var trueArms = new List <IDev2Activity>
{
dsfCaseConvertActivity
};
var trueArms1 = new List <IDev2Activity>
{
dsfCalculateActivity,
};
var uniqueId = Guid.NewGuid().ToString();
var decision = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a"
,
FalseArm = trueArms
};
var decision1 = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a"
,
FalseArm = trueArms1
};
//---------------Assert Precondition----------------
Assert.IsNotNull(decision);
//---------------Execute Test ----------------------
var equals = decision.Equals(decision1);
//---------------Test Result -----------------------
Assert.IsTrue(equals);
}
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);
}
public void UniqueIDDifferent_EmptyAssigns_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfBaseConvertActivity();
var activity1 = new DsfBaseConvertActivity();
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void GetActivityFieldsOffBaseConvertActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfBaseConvertActivity baseConvertActivity = new DsfBaseConvertActivity();
baseConvertActivity.ConvertCollection = new List <BaseConvertTO> {
new BaseConvertTO("[[FromExpression]]", "Text", "Binary", "[[ToExpression]]", 1), new BaseConvertTO("[[FromExpression2]]", "Text", "Binary", "[[ToExpression2]]", 2)
};
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
List <string> actual = strategy.GetActivityFields(baseConvertActivity);
List <string> expected = new List <string> {
"[[FromExpression]]", "[[ToExpression]]", "[[FromExpression2]]", "[[ToExpression2]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void GivenItContainsBaseConvertAs(string parentName, string activityName, Table table)
{
var activity = new DsfBaseConvertActivity {
DisplayName = activityName
};
foreach (var tableRow in table.Rows)
{
var variableToConvert = tableRow["Variable"];
var from = tableRow["From"];
var to = tableRow["To"];
activity.ConvertCollection.Add(new BaseConvertTO(variableToConvert, from, to, variableToConvert, 1, true));
}
_commonSteps.AddActivityToActivityList(parentName, activityName, activity);
}
public void DsfBaseConvertActivity_GetOutputs_Called_ShouldReturnListWithResultValueInIt()
{
//------------Setup for test--------------------------
IList <BaseConvertTO> convertCollection = new List <BaseConvertTO> {
new BaseConvertTO("[[testVar]]", "Text", "Base 64", "[[testVar]]", 1), new BaseConvertTO("[[testVar2]]", "Text", "Base 64", "[[testVar2]]", 1)
};
var act = new DsfBaseConvertActivity {
ConvertCollection = convertCollection
};
//------------Execute Test---------------------------
var outputs = act.GetOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(2, outputs.Count);
Assert.AreEqual("[[testVar]]", outputs[0]);
Assert.AreEqual("[[testVar2]]", outputs[1]);
}
public void DsfBaseConvert_GetForEachOutputs_Normal_UpdateSuccessful()
{
//------------Setup for test--------------------------
var fieldsCollection = new List <BaseConvertTO>
{
new BaseConvertTO("[[result]]", "Text", "Base 64", "[[rs(*).val]]", 1)
};
var dsfBaseConvert = new DsfBaseConvertActivity {
ConvertCollection = fieldsCollection
};
//------------Execute Test---------------------------
var inputs = dsfBaseConvert.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual("[[result]]", inputs[0].Value);
Assert.AreEqual("[[result]]", inputs[0].Name);
}
public void Equals_Given_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity = new DsfBaseConvertActivity()
{
UniqueID = uniqueId, DisplayName = "A"
};
var activity1 = new DsfBaseConvertActivity()
{
UniqueID = uniqueId, DisplayName = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(activity);
//---------------Execute Test ----------------------
var @equals = activity.Equals(activity1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
/// <summary>
/// Gets all the fields for a specific activity
/// </summary>
/// <param name="activity">The activity that the fields will be retrieved from</param>
/// <returns>Returns all the fields in a list of strings</returns>
public List <string> GetActivityFields(object activity)
{
List <string> results = new List <string>();
Type activityType = activity.GetType();
if (activityType == typeof(DsfBaseConvertActivity))
{
DsfBaseConvertActivity bcAct = activity as DsfBaseConvertActivity;
if (bcAct != null)
{
results.AddRange(InternalFindMissing(bcAct.ConvertCollection));
}
}
else if (activityType == typeof(DsfCaseConvertActivity))
{
DsfCaseConvertActivity ccAct = activity as DsfCaseConvertActivity;
if (ccAct != null)
{
results.AddRange(InternalFindMissing(ccAct.ConvertCollection));
}
}
else if (activityType == typeof(DsfMultiAssignActivity))
{
DsfMultiAssignActivity maAct = activity as DsfMultiAssignActivity;
if (maAct != null)
{
results.AddRange(InternalFindMissing(maAct.FieldsCollection));
}
}
else if (activityType == typeof(DsfGatherSystemInformationActivity))
{
DsfGatherSystemInformationActivity maAct = activity as DsfGatherSystemInformationActivity;
if (maAct != null)
{
results.AddRange(InternalFindMissing(maAct.SystemInformationCollection));
}
}
return(results);
}
public void DsfBaseConvertActivity_GetState_Returns_Inputs_And_Outputs()
{
//------------Setup for test--------------------------
IList <BaseConvertTO> convertCollection = new List <BaseConvertTO> {
new BaseConvertTO("[[testVar]]", "Text", "Base 64", "[[testVar]]", 1), new BaseConvertTO("[[testVar2]]", "Text", "Base 64", "[[testVar2]]", 1)
};
var act = new DsfBaseConvertActivity {
ConvertCollection = convertCollection
};
//------------Execute Test---------------------------
var stateList = act.GetState();
//------------Assert Results-------------------------
Assert.IsNotNull(stateList);
Assert.AreEqual(1, stateList.Count());
Assert.AreEqual(StateVariable.StateType.InputOutput, stateList.ToList()[0].Type);
Assert.AreEqual("Convert Collection", stateList.ToList()[0].Name);
var dev2JsonSerializer = new Dev2JsonSerializer();
var expectedResults = dev2JsonSerializer.Serialize(convertCollection);
Assert.AreEqual(expectedResults, stateList.ToList()[0].Value);
}
public void DsfBaseConvert_UpdateForEachInputs_WhenContainsMatchingStarAndOtherData_UpdateSuccessful()
{
//------------Setup for test--------------------------
var fieldsCollection = new List <BaseConvertTO>
{
new BaseConvertTO("[[rs(*).val]] [[result]]", "Text", "Base 64", "[[result]]", 1)
};
var dsfBaseConvert = new DsfBaseConvertActivity {
ConvertCollection = fieldsCollection
};
//------------Execute Test---------------------------
dsfBaseConvert.UpdateForEachInputs(new List <Tuple <string, string> >
{
new Tuple <string, string>("[[rs(*).val]]", "[[rs(1).val]]"),
});
//------------Assert Results-------------------------
var collection = dsfBaseConvert.ConvertCollection;
Assert.AreEqual("[[rs(1).val]] [[result]]", collection[0].FromExpression);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
var baseConvert = new DsfBaseConvertActivity();
TestStartNode = new FlowStep
{
Action = baseConvert
};
int row = 1;
var baseCollection = scenarioContext.Get <List <Tuple <string, string, string> > >("baseCollection");
foreach (dynamic variable in baseCollection)
{
baseConvert.ConvertCollection.Add(new BaseConvertTO(variable.Item1, variable.Item2, variable.Item3,
variable.Item1, row));
row++;
}
scenarioContext.Add("activity", baseConvert);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
var baseConvert = new DsfBaseConvertActivity();
TestStartNode = new FlowStep
{
Action = baseConvert
};
int row = 1;
var baseCollection = ScenarioContext.Current.Get<List<Tuple<string, string, string>>>("baseCollection");
foreach(dynamic variable in baseCollection)
{
baseConvert.ConvertCollection.Add(new BaseConvertTO(variable.Item1, variable.Item2, variable.Item3,
variable.Item1, row));
row++;
}
ScenarioContext.Current.Add("activity", baseConvert);
}
public void SequenceDesignerViewModel_ActivityNames_WhenMoreThan4_Has4NamesLastItemEllipsis()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfCaseConvertActivity);
var dsfCalculateActivity = new DsfCalculateActivity();
dsfSequenceActivity.Activities.Add(dsfCalculateActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(5, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
Assert.AreEqual("...", activityNames[4]);
CollectionAssert.DoesNotContain(activityNames, dsfCaseConvertActivity.DisplayName);
CollectionAssert.DoesNotContain(activityNames, dsfCalculateActivity.DisplayName);
}
public void SequenceDesignerViewModel_ActivityNames_WhenMoreThan4_Has4NamesLastItemEllipsis()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfCaseConvertActivity);
var dsfCalculateActivity = new DsfCalculateActivity();
dsfSequenceActivity.Activities.Add(dsfCalculateActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(5, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
Assert.AreEqual("...", activityNames[4]);
CollectionAssert.DoesNotContain(activityNames, dsfCaseConvertActivity.DisplayName);
CollectionAssert.DoesNotContain(activityNames, dsfCalculateActivity.DisplayName);
}
public void Conditions_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
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 dev2DecisionStack1 = new Dev2DecisionStack()
{
TheStack = new List <Dev2Decision>()
{
new Dev2Decision()
{
Cols1 = new List <DataStorage.WarewolfAtom>()
{
DataStorage.WarewolfAtom.NewDataString("a")
},
Col2 = "Col1"
},
new Dev2Decision()
{
Cols1 = new List <DataStorage.WarewolfAtom>()
{
DataStorage.WarewolfAtom.NewDataString("a")
}
}
},
DisplayText = "a"
,
FalseArmText = "ErrorArm"
,
TrueArmText = "true Arm",
Version = "2",
Mode = Dev2DecisionMode.AND
};
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);
}
public void SequenceDesignerViewModel_ActivityNames_When4_HasAllNames()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(4, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
}
public void GivenItContainsBaseConvertAs(string parentName, string activityName, Table table)
{
DsfBaseConvertActivity activity = new DsfBaseConvertActivity { DisplayName = activityName };
foreach(var tableRow in table.Rows)
{
var variableToConvert = tableRow["Variable"];
var from = tableRow["From"];
var to = tableRow["To"];
activity.ConvertCollection.Add(new BaseConvertTO(variableToConvert, from, to, variableToConvert, 1, true));
}
CommonSteps.AddActivityToActivityList(parentName, activityName, activity);
}
/// <summary>
/// Gets all the fields for a specific activity
/// </summary>
/// <param name="activity">The activity that the fields will be retrieved from</param>
/// <returns>Returns all the fields in a list of strings</returns>
public List <string> GetActivityFields(object activity)
{
List <string> results = new List <string>();
Type activityType = activity.GetType();
if (activityType == typeof(DsfBaseConvertActivity))
{
DsfBaseConvertActivity bcAct = activity as DsfBaseConvertActivity;
if (bcAct != null)
{
results.AddRange(InternalFindMissing(bcAct.ConvertCollection));
}
}
else if (activityType == typeof(DsfCaseConvertActivity))
{
DsfCaseConvertActivity ccAct = activity as DsfCaseConvertActivity;
if (ccAct != null)
{
results.AddRange(InternalFindMissing(ccAct.ConvertCollection));
}
}
else if (activityType == typeof(DsfMultiAssignActivity))
{
DsfMultiAssignActivity maAct = activity as DsfMultiAssignActivity;
if (maAct != null)
{
results.AddRange(InternalFindMissing(maAct.FieldsCollection));
}
}
else if (activityType == typeof(DsfMultiAssignObjectActivity))
{
DsfMultiAssignObjectActivity maAct = activity as DsfMultiAssignObjectActivity;
if (maAct != null)
{
results.AddRange(InternalFindMissing(maAct.FieldsCollection));
}
}
else if (activityType == typeof(DsfGatherSystemInformationActivity))
{
DsfGatherSystemInformationActivity maAct = activity as DsfGatherSystemInformationActivity;
if (maAct != null)
{
results.AddRange(InternalFindMissing(maAct.SystemInformationCollection));
}
}
else if (activityType == typeof(DsfSqlServerDatabaseActivity))
{
var maAct = activity as DsfSqlServerDatabaseActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfMySqlDatabaseActivity))
{
var maAct = activity as DsfMySqlDatabaseActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfPostgreSqlActivity))
{
var maAct = activity as DsfPostgreSqlActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfOracleDatabaseActivity))
{
var maAct = activity as DsfOracleDatabaseActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfODBCDatabaseActivity))
{
var maAct = activity as DsfODBCDatabaseActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.CommandText != null)
{
results.Add(maAct.CommandText);
}
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfWebPostActivity))
{
var maAct = activity as DsfWebPostActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.QueryString != null)
{
results.Add(maAct.QueryString);
}
if (maAct.PostData != null)
{
results.Add(maAct.PostData);
}
if (maAct.Headers != null)
{
foreach (var nameValue in maAct.Headers)
{
results.Add(nameValue.Name);
results.Add(nameValue.Value);
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
}
}
else if (activityType == typeof(DsfWebDeleteActivity))
{
var maAct = activity as DsfWebDeleteActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.QueryString != null)
{
results.Add(maAct.QueryString);
}
if (maAct.Headers != null)
{
foreach (var nameValue in maAct.Headers)
{
results.Add(nameValue.Name);
results.Add(nameValue.Value);
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfWebPutActivity))
{
var maAct = activity as DsfWebPutActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.QueryString != null)
{
results.Add(maAct.QueryString);
}
if (maAct.PutData != null)
{
results.Add(maAct.PutData);
}
if (maAct.Headers != null)
{
foreach (var nameValue in maAct.Headers)
{
results.Add(nameValue.Name);
results.Add(nameValue.Value);
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfWebGetActivity))
{
var maAct = activity as DsfWebGetActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.QueryString != null)
{
results.Add(maAct.QueryString);
}
if (maAct.Headers != null)
{
foreach (var nameValue in maAct.Headers)
{
results.Add(nameValue.Name);
results.Add(nameValue.Value);
}
}
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfDotNetDllActivity))
{
var maAct = activity as DsfDotNetDllActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfEnhancedDotNetDllActivity))
{
var maAct = activity as DsfEnhancedDotNetDllActivity;
if (maAct != null)
{
if (maAct.ConstructorInputs != null)
{
results.AddRange(InternalFindMissing(maAct.ConstructorInputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.MethodsToRun != null)
{
foreach (var pluginAction in maAct.MethodsToRun)
{
if (pluginAction?.Inputs != null)
{
results.AddRange(InternalFindMissing(pluginAction.Inputs));
}
if (!string.IsNullOrEmpty(pluginAction?.OutputVariable))
{
results.Add(pluginAction.OutputVariable);
}
}
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfComDllActivity))
{
var maAct = activity as DsfComDllActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfWcfEndPointActivity))
{
var maAct = activity as DsfWcfEndPointActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
return(results);
}
