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); }