void InsertToCollection(IEnumerable <string> listToAdd, ModelItem modelItem)
{
var modelProperty = modelItem.Properties["ResultsCollection"];
if (modelProperty == null)
{
return;
}
var mic = modelProperty.Collection;
if (mic == null)
{
return;
}
var listOfValidRows = ResultsCollection.Where(c => !c.CanRemove()).ToList();
if (listOfValidRows.Count > 0)
{
FindRecordsTO findRecordsTo = ResultsCollection.Last(c => !c.CanRemove());
var startIndex = ResultsCollection.IndexOf(findRecordsTo) + 1;
foreach (var s in listToAdd)
{
mic.Insert(startIndex, new FindRecordsTO(s, ResultsCollection[startIndex - 1].SearchType, startIndex + 1));
startIndex++;
}
CleanUpCollection(mic, modelItem, startIndex);
}
else
{
AddToCollection(listToAdd, modelItem);
}
}
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index = 0, bool inserted = false, string initializeWith = "")
{
IDev2TOFn toReturn = null;
TypeSwitch.Do(dto,
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case<ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
TypeSwitch.Case<DataSplitDTO>(x =>
{
var dataSplitDto = dto as DataSplitDTO;
if(dataSplitDto != null)
{
toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
}
}),
TypeSwitch.Case<DataMergeDTO>(x =>
{
var dataMergeDto = dto as DataMergeDTO;
if(dataMergeDto != null)
{
toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
}
}),
TypeSwitch.Case<CaseConvertTO>(x =>
{
var caseConvertTO = dto as CaseConvertTO;
if(caseConvertTO != null)
{
toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
}
}),
TypeSwitch.Case<BaseConvertTO>(x =>
{
var baseConvertTO = dto as BaseConvertTO;
if(baseConvertTO != null)
{
toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
}
}),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case<GatherSystemInformationTO>(x => toReturn =
// ReSharper restore ImplicitlyCapturedClosure
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
initializeWith, index, inserted)),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case<XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case<FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Default(() => toReturn = null));
// ReSharper restore ImplicitlyCapturedClosure
return toReturn;
}
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index = 0, bool inserted = false, string initializeWith = "")
{
IDev2TOFn toReturn = null;
TypeSwitch.Do(dto,
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
TypeSwitch.Case <DataSplitDTO>(x =>
{
var dataSplitDto = dto as DataSplitDTO;
if (dataSplitDto != null)
{
toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
}
}),
TypeSwitch.Case <DataMergeDTO>(x =>
{
var dataMergeDto = dto as DataMergeDTO;
if (dataMergeDto != null)
{
toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
}
}),
TypeSwitch.Case <CaseConvertTO>(x =>
{
var caseConvertTO = dto as CaseConvertTO;
if (caseConvertTO != null)
{
toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
}
}),
TypeSwitch.Case <BaseConvertTO>(x =>
{
var baseConvertTO = dto as BaseConvertTO;
if (baseConvertTO != null)
{
toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
}
}),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn =
// ReSharper restore ImplicitlyCapturedClosure
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
initializeWith, index, inserted)),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Default(() => toReturn = null));
// ReSharper restore ImplicitlyCapturedClosure
return(toReturn);
}
public void FindRecordsTO_SearchCriteria_SetValue_FiresNotifyPropertyChanged()
{
//------------Setup for test--------------------------
var findRecordsTO = new FindRecordsTO();
const string searchCriteria = "MyValue";
//------------Execute Test---------------------------
// ReSharper disable ImplicitlyCapturedClosure
var notifyPropertyChanged = TestUtils.PropertyChangedTester(findRecordsTO, () => findRecordsTO.SearchCriteria, () => findRecordsTO.SearchCriteria = searchCriteria);
// ReSharper restore ImplicitlyCapturedClosure
//------------Assert Results-------------------------
Assert.AreEqual(searchCriteria, findRecordsTO.SearchCriteria);
Assert.IsTrue(notifyPropertyChanged);
}
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index, bool inserted, string initializeWith)
{
IDev2TOFn toReturn = null;
TypeSwitch.Do(dto,
TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
TypeSwitch.Case <DataSplitDTO>(x =>
{
if (dto is DataSplitDTO dataSplitDto)
{
toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
}
}),
TypeSwitch.Case <DataMergeDTO>(x =>
{
if (dto is DataMergeDTO dataMergeDto)
{
toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
}
}),
TypeSwitch.Case <CaseConvertTO>(x =>
{
if (dto is CaseConvertTO caseConvertTO)
{
toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
}
}),
TypeSwitch.Case <BaseConvertTO>(x =>
{
if (dto is BaseConvertTO baseConvertTO)
{
toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
}
}),
TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn =
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
initializeWith, index, inserted)),
TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
TypeSwitch.Case <DecisionTO>(() => toReturn = new DecisionTO(initializeWith, "", "", index, inserted)),
TypeSwitch.Case <JsonMappingTo>(() => toReturn = new JsonMappingTo(initializeWith, index, inserted)),
TypeSwitch.Case <SharepointSearchTo>(() => toReturn = new SharepointSearchTo(initializeWith, "=", "", index, inserted)),
TypeSwitch.Case <SharepointReadListTo>(() => toReturn = new SharepointReadListTo("", initializeWith, "", "")),
TypeSwitch.Case <AssignObjectDTO>(x => toReturn = new AssignObjectDTO(initializeWith, "", index, inserted)),
TypeSwitch.Default(() => toReturn = null));
return(toReturn);
}
public void FindRecordsTO_Constructor_Default_SetsProperties()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var findRecordsTO = new FindRecordsTO();
//------------Assert Results-------------------------
Assert.IsNotNull(findRecordsTO);
Assert.AreEqual("Match On", findRecordsTO.SearchCriteria);
Assert.AreEqual("Equal", findRecordsTO.SearchType);
Assert.AreEqual(0, findRecordsTO.IndexNumber);
Assert.IsFalse(findRecordsTO.Inserted);
Assert.IsFalse(findRecordsTO.IsSearchCriteriaEnabled);
}
public void FindRecordsTO_ParameterConstructor_SetsProperties()
{
//------------Setup for test--------------------------
const string searchCriteria = "Bob";
const string searchType = ">";
const int indexNum = 3;
//------------Execute Test---------------------------
var findRecordsTO = new FindRecordsTO(searchCriteria, searchType, indexNum);
//------------Assert Results-------------------------
Assert.IsNotNull(findRecordsTO);
Assert.AreEqual(searchCriteria, findRecordsTO.SearchCriteria);
Assert.AreEqual(searchType, findRecordsTO.SearchType);
Assert.AreEqual(indexNum, findRecordsTO.IndexNumber);
Assert.IsFalse(findRecordsTO.Inserted);
Assert.IsFalse(findRecordsTO.IsSearchCriteriaEnabled);
}
static void ValidateRequiredFields(FindRecordsTO searchTo, ErrorResultTO errors)
{
if (string.IsNullOrEmpty(searchTo.SearchType))
{
errors.AddError(string.Format(ErrorResource.IsRequired, "Search Type"));
}
if (searchTo.SearchType.Equals("Is Between"))
{
if (string.IsNullOrEmpty(searchTo.From))
{
errors.AddError(string.Format(ErrorResource.IsRequired, "FROM"));
}
if (string.IsNullOrEmpty(searchTo.To))
{
errors.AddError(string.Format(ErrorResource.IsRequired, "TO"));
}
}
}
private void ValidateRequiredFields(FindRecordsTO searchTo, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
if (string.IsNullOrEmpty(searchTo.SearchType))
{
errors.AddError("Search type is required");
}
if (searchTo.SearchType.Equals("Is Between"))
{
if (string.IsNullOrEmpty(searchTo.From))
{
errors.AddError("From is required");
}
if (string.IsNullOrEmpty(searchTo.To))
{
errors.AddError("To is required");
}
}
}
public void FindRecordsTO_GetRuleSet_OnSearchCriteriaSearchTypeAsDoesntStartWith_ReturnTwoRules()
{
//------------Setup for test--------------------------
var findRecordsTO = new FindRecordsTO { SearchType = "Doesn't Start With", SearchCriteria = string.Empty };
VerifyCorrectRulesForEachFieldSearch(findRecordsTO, "SearchCriteria");
}
void Verify_OnSearchTypeChanged_IsSearchCriteriaEnabled(string searchType, bool isSearchCriteriaEnabled, bool isSearchCriteriaBlank, int indexObject = 0)
{
//------------Setup for test--------------------------
var findRecordsTO = new FindRecordsTO("xxxx", searchType, 1);
var items = new List<FindRecordsTO>
{
findRecordsTO
};
var viewModel = new FindRecordsMultipleCriteriaDesignerViewModel(CreateModelItem(items));
//------------Precondition---------------------------
Assert.IsFalse(findRecordsTO.IsSearchCriteriaEnabled);
//------------Execute Test---------------------------
viewModel.SearchTypeUpdatedCommand.Execute(indexObject);
//viewModel.SearchTypeUpdatedCommand.Execute(0);
//------------Assert Results-------------------------
Assert.AreEqual(isSearchCriteriaEnabled, findRecordsTO.IsSearchCriteriaEnabled);
Assert.AreEqual(isSearchCriteriaBlank, string.IsNullOrEmpty(findRecordsTO.SearchCriteria));
}
public void FindRecordsTO_IndexNum_SetValue_FiresNotifyPropertyChanged()
{
//------------Setup for test--------------------------
var findRecordsTO = new FindRecordsTO();
const int indexNum = 5;
//------------Execute Test---------------------------
var notifyPropertyChanged = TestUtils.PropertyChangedTester(findRecordsTO, () => findRecordsTO.IndexNumber, () => findRecordsTO.IndexNumber = indexNum);
//------------Assert Results-------------------------
Assert.AreEqual(indexNum, findRecordsTO.IndexNumber);
Assert.IsTrue(notifyPropertyChanged);
}
public void FindRecordsMultipleCriteriaDesignerViewModel_ValidateCollectionItem_ValidatesPropertiesOfTO()
{
//------------Setup for test--------------------------
var mi = ModelItemUtils.CreateModelItem(new DsfFindRecordsMultipleCriteriaActivity());
mi.SetProperty("DisplayName", "Find");
mi.SetProperty("FieldsToSearch", "a,b");
mi.SetProperty("Result", "[[a]]");
var dto1 = new FindRecordsTO("", "Starts With", 0);
var dto2 = new FindRecordsTO("", "Ends With", 1);
var dto3 = new FindRecordsTO("", "Doesn't Start With", 2);
var dto4 = new FindRecordsTO("", "Doesn't End With", 3);
var dto5 = new FindRecordsTO("", "Is Between", 4);
var dto6 = new FindRecordsTO("", "Is Not Between", 5);
// ReSharper disable PossibleNullReferenceException
var miCollection = mi.Properties["ResultsCollection"].Collection;
var dtoModelItem1 = miCollection.Add(dto1);
var dtoModelItem2 = miCollection.Add(dto2);
var dtoModelItem3 = miCollection.Add(dto3);
var dtoModelItem4 = miCollection.Add(dto4);
var dtoModelItem5 = miCollection.Add(dto5);
var dtoModelItem6 = miCollection.Add(dto6);
// ReSharper restore PossibleNullReferenceException
var viewModel = new FindRecordsMultipleCriteriaDesignerViewModel(mi);
SetDataListString(viewModel);
//------------Execute Test---------------------------
viewModel.Validate();
//------------Assert Results-------------------------
Assert.AreEqual(10, viewModel.Errors.Count);
StringAssert.Contains(viewModel.Errors[0].Message, "'Match' cannot be empty");
Verify_IsFocused(dtoModelItem1, viewModel.Errors[0].Do, "IsSearchCriteriaFocused");
StringAssert.Contains(viewModel.Errors[1].Message, "'Match' cannot be empty");
Verify_IsFocused(dtoModelItem2, viewModel.Errors[1].Do, "IsSearchCriteriaFocused");
StringAssert.Contains(viewModel.Errors[2].Message, "'Match' cannot be empty");
Verify_IsFocused(dtoModelItem3, viewModel.Errors[2].Do, "IsSearchCriteriaFocused");
StringAssert.Contains(viewModel.Errors[3].Message, "'Match' cannot be empty");
Verify_IsFocused(dtoModelItem4, viewModel.Errors[3].Do, "IsSearchCriteriaFocused");
StringAssert.Contains(viewModel.Errors[4].Message, "'Match' cannot be empty");
Verify_IsFocused(dtoModelItem5, viewModel.Errors[4].Do, "IsSearchCriteriaFocused");
StringAssert.Contains(viewModel.Errors[5].Message, "'From' cannot be empty");
Verify_IsFocused(dtoModelItem5, viewModel.Errors[5].Do, "IsFromFocused");
StringAssert.Contains(viewModel.Errors[6].Message, "'To' cannot be empty");
Verify_IsFocused(dtoModelItem5, viewModel.Errors[6].Do, "IsToFocused");
StringAssert.Contains(viewModel.Errors[7].Message, "'Match' cannot be empty");
Verify_IsFocused(dtoModelItem6, viewModel.Errors[7].Do, "IsSearchCriteriaFocused");
StringAssert.Contains(viewModel.Errors[9].Message, "'To' cannot be empty");
Verify_IsFocused(dtoModelItem6, viewModel.Errors[9].Do, "IsToFocused");
}
static void VerifyCorrectRulesForEachFieldSearch(FindRecordsTO findRecordsTO, string fieldName)
{
//------------Execute Test---------------------------
var rulesSet = findRecordsTO.GetRuleSet(fieldName, "");
//------------Assert Results-------------------------
Assert.IsNotNull(rulesSet);
Assert.IsInstanceOfType(rulesSet.Rules[0], typeof(IsValidExpressionRule));
}
public void FindRecordsTO_GetRuleSet_OnToSearchTypeAsIsNotBetween_ReturnTwoRules()
{
//------------Setup for test--------------------------
var findRecordsTO = new FindRecordsTO { SearchType = "Is Not Between", SearchCriteria = string.Empty };
VerifyCorrectRulesForEachField(findRecordsTO, "To");
}
public void FindRecordsTO_CanRemove_SearchTypeEmptyAndSearchTypeWithData_ReturnFalse()
{
//------------Setup for test--------------------------
var findRecordsTO = new FindRecordsTO { SearchType = string.Empty, SearchCriteria = "Data" };
//------------Execute Test---------------------------
Assert.IsFalse(findRecordsTO.CanRemove());
//------------Assert Results-------------------------
}
public void FindRecordsTO_CanAdd_SearchTypeWithData_ReturnTrue()
{
//------------Setup for test--------------------------
var findRecordsTO = new FindRecordsTO { SearchType = "Contains" };
//------------Execute Test---------------------------
Assert.IsTrue(findRecordsTO.CanAdd());
//------------Assert Results-------------------------
}
public void FindRecordsTO_CanAdd_SearchTypeEmpty_ReturnFalse()
{
//------------Setup for test--------------------------
var findRecordsTO = new FindRecordsTO { SearchType = string.Empty };
//------------Execute Test---------------------------
Assert.IsFalse(findRecordsTO.CanAdd());
//------------Assert Results-------------------------
}
public void FindRecordsTO_IsSearchCriteriaEnabled_SetValue_FiresNotifyPropertyChanged()
{
//------------Setup for test--------------------------
var findRecordsTO = new FindRecordsTO();
const bool isSearchCriteriaEnabled = true;
//------------Execute Test---------------------------
var notifyPropertyChanged = TestUtils.PropertyChangedTester(findRecordsTO, () => findRecordsTO.IsSearchCriteriaEnabled, () => findRecordsTO.IsSearchCriteriaEnabled = isSearchCriteriaEnabled);
//------------Assert Results-------------------------
Assert.AreEqual(isSearchCriteriaEnabled, findRecordsTO.IsSearchCriteriaEnabled);
Assert.IsTrue(notifyPropertyChanged);
}
