public void VisitSearchQueryRule(SearchQueryRule <T> searchQueryRule) { Assert.ArgumentNotNull(searchQueryRule, "searchQueryRule"); var value = SearchQueryValueProvider.GetValueForSearchQueryRule(searchQueryRule); if (value == null) { return; } var predicate = GetPredicateFromSearchQueryRule(searchQueryRule, value); var builderContext = _predicateBuilderContext.Peek(); switch (builderContext.LogicalOperator) { case LogicalOperator.And: builderContext.Predicate = builderContext.Predicate.And(predicate); break; case LogicalOperator.Or: builderContext.Predicate = builderContext.Predicate.Or(predicate); break; default: throw new ArgumentOutOfRangeException(); } }
public void VisitSearchQueryGrouping_WithRules_ReturnExpression( SearchQueryPredicateBuilder <TestIndexableEntity> sut) { // Arrange Expression <Func <TestIndexableEntity, bool> > expected = x => (x.SomeInteger == 1 || x.SomeBoolean == false); var indexableEntity = new TestIndexableEntity(); var integerEqualsRule = new SearchQueryRule <TestIndexableEntity>( x => x.SomeInteger, ComparisonOperator.Equal, null, "1" ); var booleanEqualsRule = new SearchQueryRule <TestIndexableEntity>( x => x.SomeBoolean, ComparisonOperator.Equal, null, "false" ); var searchQueryGrouping = new SearchQueryGrouping <TestIndexableEntity>(LogicalOperator.Or); searchQueryGrouping.SearchQueryElements.Add(integerEqualsRule); searchQueryGrouping.SearchQueryElements.Add(booleanEqualsRule); sut.SearchQueryValueProvider.GetValueForSearchQueryRule(integerEqualsRule).Returns(1); sut.SearchQueryValueProvider.GetValueForSearchQueryRule(booleanEqualsRule).Returns(false); // Act searchQueryGrouping.Accept(sut); Expression <Func <TestIndexableEntity, bool> > actual = sut.GetOutput(); // Assert Assert.Equal(actual.Compile().Invoke(indexableEntity), expected.Compile().Invoke(indexableEntity)); }
public void VisitSearchQueryRule_DefaultOrDynamicValueFound_ReturnsExpression( SearchQueryPredicateBuilder <TestIndexableEntity> sut) { // Arrange var value = 1; Expression <Func <TestIndexableEntity, bool> > expected = x => (x.SomeInteger == value); var indexableEntity = new TestIndexableEntity(); var searchQueryRule = new SearchQueryRule <TestIndexableEntity>(x => x.SomeInteger, ComparisonOperator.Equal); var searchRootItem = new SearchQueryGrouping <TestIndexableEntity>(LogicalOperator.And); searchRootItem.SearchQueryElements.Add(searchQueryRule); sut .SearchQueryValueProvider .GetValueForSearchQueryRule(searchQueryRule) .Returns(x => value); // Act searchRootItem.Accept(sut); Expression <Func <TestIndexableEntity, bool> > actual = sut.GetOutput(); // Assert Assert.Equal(actual.Compile().Invoke(indexableEntity), expected.Compile().Invoke(indexableEntity)); }
private void VisitSearchQueryRule_PropertyOfType_ReturnsExpression(Expression <Func <TestIndexableEntity, object> > propertySelector, TestIndexableEntity indexableEntity, object value, Expression <Func <TestIndexableEntity, bool> > expected) { // Arrange var searchQueryRule = new SearchQueryRule <TestIndexableEntity>(propertySelector, ComparisonOperator.Contains); var searchRootItem = new SearchQueryGrouping <TestIndexableEntity>(LogicalOperator.And); searchRootItem.SearchQueryElements.Add(searchQueryRule); var valueProviderMock = Substitute.For <ISearchQueryValueProvider>(); valueProviderMock.GetValueForSearchQueryRule(searchQueryRule).Returns(value); var sut = new SearchQueryPredicateBuilder <TestIndexableEntity>(valueProviderMock); // Act searchRootItem.Accept(sut); var actual = sut.GetOutput(); // Assert Assert.Equal(actual.Compile().Invoke(indexableEntity), expected.Compile().Invoke(indexableEntity)); }
private SearchQueryRule BuildSearchQueryRule(DuplicatesRuleDTO rule, List <DuplicatesColumnData> model, string schemaName) { if (rule.RuleBody == null) { return(null); } var ruleBody = rule.RuleBody; if (string.IsNullOrEmpty(ruleBody.RootSchemaName) || ruleBody.RootSchemaName == schemaName) { var searchQueryRule = new SearchQueryRule { Filters = new List <SearchQueryFilter>() }; foreach (var ruleFiler in ruleBody.Filters) { var searchQueryFilter = BuildSearchQueryFilter(ruleFiler, model); if (searchQueryFilter != null) { searchQueryRule.Filters.Add(searchQueryFilter); } else { return(null); } } return(searchQueryRule); } return(null); }
/// <summary> /// Returns the value needed by the search query value. /// </summary> /// <typeparam name="T">The type of <see cref="IndexableEntity"/> implementation to use.</typeparam> /// <param name="searchQueryRule">The specifed search query rule</param> /// <returns>A typed value</returns> public object GetValueForSearchQueryRule <T>(SearchQueryRule <T> searchQueryRule) where T : IndexableEntity, new() { Assert.ArgumentNotNull(searchQueryRule, "searchQueryRule"); object retVal; var value = GetRawDefaultOrDynamicValueProvidedByParameter(searchQueryRule); if (string.IsNullOrWhiteSpace(value)) { return(null); } var propertyType = ExpressionUtils.GetPropertyTypeFromPropertySelector(searchQueryRule.PropertySelector); Tuple <string, string> rangeValueParts; if (SearchQueryValueConversionService.TryConvertToRangeValueParts(value, out rangeValueParts)) { var lowerValue = SearchQueryValueConversionService.ToTypedValue(propertyType, rangeValueParts.Item1); var upperValue = SearchQueryValueConversionService.ToTypedValue(propertyType, rangeValueParts.Item2); retVal = new RangeValue(lowerValue, upperValue); } else { retVal = SearchQueryValueConversionService.ToTypedValue(propertyType, value); } return(retVal); }
public void GetValueForSearchQueryRule_SearchQueryRuleIsNull_ThrowsException() { // Arrange SearchQueryRule <TestIndexableEntity> searchQueryRule = null; var parameterNameValuePairs = new NameValueCollection(); var sut = new NameValuePairSearchQueryValueProvider(() => parameterNameValuePairs); // Act Action act = () => sut.GetValueForSearchQueryRule(searchQueryRule); // Assert act.ShouldThrow <ArgumentNullException>(); }
public void GetValueForSearchQueryRule_DynamicValueProvidingParameterNotSetForSearchQueryRule_ReturnsDefaultValue(string defaultValue) { // Arrange var propertySelector = ExpressionUtils.GetPropertySelector <TestIndexableEntity, object>(TestIndexableEntityPropertyName); var searchQueryRule = new SearchQueryRule <TestIndexableEntity>(propertySelector, ComparisonOperator.Equal, defaultValue: defaultValue); var parameterNameValuePairs = new NameValueCollection(); var sut = new NameValuePairSearchQueryValueProvider(() => parameterNameValuePairs); // Act var actual = sut.GetValueForSearchQueryRule(searchQueryRule); // Assert actual.ShouldBeEquivalentTo(defaultValue); }
private QueryContainer BuildSingleRuleContainer(SearchQueryRule rule) { var filters = rule.Filters; using (var filterEnumerator = filters.GetEnumerator()) { filterEnumerator.MoveNext(); var currentFilter = filterEnumerator.Current; var resultContainer = BuildFilterQuery(currentFilter); while (filterEnumerator.MoveNext()) { currentFilter = filterEnumerator.Current; resultContainer = resultContainer && BuildFilterQuery(currentFilter); } return(resultContainer); } }
public void GetValueForSearchQueryRule_SingleDynamicValueProvidedByQueryStringParameter_ReturnsSingleValue() { // Arrange var propertySelector = ExpressionUtils.GetPropertySelector <TestIndexableEntity, object>(TestIndexableEntityPropertyName); var searchQueryRule = new SearchQueryRule <TestIndexableEntity>(propertySelector, ComparisonOperator.Equal, ParameterName); var parameterValue = "someValue"; var parameterNameValuePairs = new NameValueCollection { { ParameterName, parameterValue } }; var sut = new NameValuePairSearchQueryValueProvider(() => parameterNameValuePairs); // Act var actual = sut.GetValueForSearchQueryRule(searchQueryRule); // Assert actual.ShouldBeEquivalentTo(parameterValue); }
public void VisitSearchQueryRule_DefaultOrDynamicValueNotFound_ReturnsNullExpression( SearchQueryPredicateBuilder <TestIndexableEntity> sut) { // Arrange var searchQueryRule = new SearchQueryRule <TestIndexableEntity>(x => x.SomeInteger, ComparisonOperator.Equal); sut .SearchQueryValueProvider .GetValueForSearchQueryRule(searchQueryRule) .Returns(x => null); // Act searchQueryRule.Accept(sut); Expression <Func <TestIndexableEntity, bool> > actual = sut.GetOutput(); // Assert actual.Should().BeNull(); }
protected override string GetRawDefaultOrDynamicValueProvidedByParameter <T>(SearchQueryRule <T> searchQueryRule) { string value; if (string.IsNullOrWhiteSpace(searchQueryRule.DynamicValueProvidingParameter)) { value = searchQueryRule.DefaultValue; } else { var valueProviderParameterName = searchQueryRule.DynamicValueProvidingParameter; var nameValuePairs = _nameValuePairFactory(); if (nameValuePairs == null) { throw new InvalidOperationException("The nameValuePairs cannot be null"); } value = nameValuePairs[valueProviderParameterName]; } return(value); }
private static Expression <Func <T, bool> > GetPredicateFromSearchQueryRule(SearchQueryRule <T> searchQueryRule, object value) { Expression <Func <T, bool> > predicate; switch (searchQueryRule.ComparisonOperator) { case ComparisonOperator.GreaterThanOrEqual: predicate = ExpressionConversionService.ToGreaterThanOrEqual(searchQueryRule.PropertySelector, value); break; case ComparisonOperator.LessThanOrEqual: predicate = ExpressionConversionService.ToLessThanOrEqual(searchQueryRule.PropertySelector, value); break; case ComparisonOperator.Equal: predicate = ExpressionConversionService.ToEquals(searchQueryRule.PropertySelector, value); break; case ComparisonOperator.Contains: predicate = GetContainsPredicateFromSearchQueryRule(searchQueryRule, value); break; case ComparisonOperator.Between: var rangeValue = (RangeValue)value; predicate = ExpressionConversionService.ToBetween(searchQueryRule.PropertySelector, rangeValue.LowerValue, rangeValue.UpperValue); break; case ComparisonOperator.GreaterThan: case ComparisonOperator.LessThan: case ComparisonOperator.NotEqual: case ComparisonOperator.NotContains: case ComparisonOperator.NotBetween: default: throw new NotSupportedException(); } return(predicate); }
public void VisitSearchQueryRule(SearchQueryRule <T> searchQueryRule) { throw new NotImplementedException(); }
private static Expression <Func <T, bool> > GetContainsPredicateFromSearchQueryRule(SearchQueryRule <T> searchQueryRule, object value) { Expression <Func <T, bool> > predicate; // There are 3 cases that needs to be handled: // 1) The property is of type String: Perform a 'Contains' operation on the string property // 2) The property is of type IEnumerable<>: Perform a 'Contains' operation on the IEnumerable<> property // 3) The property is a general type, like ID or Guid: Perform an 'Equals' operation on the property Type propertyTypeFromPropertySelector = ExpressionUtils.GetPropertyTypeFromPropertySelector(searchQueryRule.PropertySelector); if (propertyTypeFromPropertySelector == typeof(string)) { predicate = ExpressionConversionService.ToContains(searchQueryRule.PropertySelector, (string)value); } else if (typeof(IEnumerable).IsAssignableFrom(propertyTypeFromPropertySelector)) { predicate = ExpressionConversionService.ToEnumerableContains(searchQueryRule.PropertySelector, value); } else { predicate = ExpressionConversionService.ToEquals(searchQueryRule.PropertySelector, value); } return(predicate); }
/// <summary> /// Retruns the raw value of either the default or dynamically provided value. /// </summary> /// <typeparam name="T">The type of <see cref="IndexableEntity"/> implementation to use.</typeparam> /// <param name="searchQueryRule">The specifed search query rule</param> /// <returns>A raw string value of either the default or dynamically provided value</returns> protected abstract string GetRawDefaultOrDynamicValueProvidedByParameter <T>(SearchQueryRule <T> searchQueryRule) where T : IndexableEntity, new();