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