public static bool MatchesFilter(SubmissionMetaDataModel model, SearchTermModel filter)
{
var modelValue = GetNumericalValue(model?.Value);
var filterValue = GetNumericalValue(filter?.FieldValue);
switch (filter.OperatorProperty)
{
case FilterConstants.CommonFieldOperators.Equal:
return(modelValue == filterValue);
case FilterConstants.CommonFieldOperators.NotEqual:
return(modelValue != filterValue);
case FilterConstants.CommonFieldOperators.Empty:
return(modelValue == null);
case FilterConstants.CommonFieldOperators.NotEmpty:
return(modelValue != null);
case FilterConstants.NumericalFieldOperators.GreaterThan:
return(modelValue > filterValue);
case FilterConstants.NumericalFieldOperators.GreaterThanOrEqualTo:
return(modelValue >= filterValue);
case FilterConstants.NumericalFieldOperators.LessThan:
return(modelValue < filterValue);
case FilterConstants.NumericalFieldOperators.LessThanOrEqualTo:
return(modelValue <= filterValue);
default: throw new NotImplementedException($"Filter for FieldName [{filter.FieldName}] has invalid OperatorProperty [{filter.OperatorProperty}]");
}
}
public static bool MatchesFilter(SubmissionMetaDataModel model, SearchTermModel filter)
{
switch (filter.OperatorProperty)
{
case FilterConstants.CommonFieldOperators.Equal:
{
return(IsEqual(model, filter.FieldValue));
}
case FilterConstants.CommonFieldOperators.NotEqual:
{
return(!IsEqual(model, filter.FieldValue));
}
case FilterConstants.CommonFieldOperators.Empty:
{
return(string.IsNullOrEmpty(model?.Value));
}
case FilterConstants.CommonFieldOperators.NotEmpty:
{
return(!string.IsNullOrEmpty(model?.Value));
}
case FilterConstants.StringFieldOperators.Contains:
{
return(IsContains(model, filter.FieldValue));
}
case FilterConstants.StringFieldOperators.NotContains:
{
return(!IsContains(model, filter.FieldValue));
}
case FilterConstants.StringFieldOperators.EndsWith:
{
return(IsEndsWith(model, filter.FieldValue));
}
case FilterConstants.StringFieldOperators.NotEndsWith:
{
return(!IsEndsWith(model, filter.FieldValue));
}
case FilterConstants.StringFieldOperators.StartsWith:
{
return(IsStartsWith(model, filter.FieldValue));
}
case FilterConstants.StringFieldOperators.NotStartsWith:
{
return(!IsStartsWith(model, filter.FieldValue));
}
default:
{
throw new NotImplementedException($"Filter for FieldName [{filter.FieldName}] has invalid OperatorProperty [{filter.OperatorProperty}]");
}
}
}
private static bool IsEndsWith(SubmissionMetaDataModel model, string expectedValue)
{
if (!string.IsNullOrEmpty(model?.Value))
{
return(model.Value.EndsWith(expectedValue, StringComparison.InvariantCultureIgnoreCase));
}
return(false);
}
public static bool MatchesFilter(SubmissionMetaDataModel model, SearchTermModel filter)
{
var fieldValue = GetDateTimeValue(model?.Value);
var filterValue = GetDateTimeValue(filter.FieldValue);
switch (filter.OperatorProperty)
{
case FilterConstants.CommonFieldOperators.Equal:
{
if (fieldValue.HasValue && filterValue.HasValue)
{
return(fieldValue.Value >= filterValue.Value && fieldValue < filterValue.Value.AddHours(24));
}
else
{
return(fieldValue == filterValue);
}
}
case FilterConstants.CommonFieldOperators.NotEqual:
{
if (fieldValue.HasValue && filterValue.HasValue)
{
return(fieldValue.Value < filterValue.Value || fieldValue >= filterValue.Value.AddHours(24));
}
else
{
return(fieldValue != filterValue);
}
}
case FilterConstants.CommonFieldOperators.Empty:
{
return(fieldValue == null);
}
case FilterConstants.CommonFieldOperators.NotEmpty:
{
return(fieldValue != null);
}
case FilterConstants.DateFieldOperators.Before:
{
return(fieldValue < filterValue);
}
case FilterConstants.DateFieldOperators.After:
{
return(fieldValue > filterValue);
}
default:
{
throw new NotImplementedException($"Filter for FieldName [{filter.FieldName}] has invalid OperatorProperty [{filter.OperatorProperty}]");
}
}
}
private static bool IsContains(SubmissionMetaDataModel model, string expectedValue)
{
if (!string.IsNullOrEmpty(model?.Value))
{
//string.Contains doesn't have option to check with ignoreCase, that's why used IndexOf method
//for reference https://stackoverflow.com/questions/444798/case-insensitive-containsstring/15464440#15464440
return(model.Value.IndexOf(expectedValue, StringComparison.OrdinalIgnoreCase) >= 0);
}
return(false);
}
private static bool IsEqual(SubmissionMetaDataModel model, string expectedValue)
{
// Validation should prevent an equals operation on an empty string - Users can
// use an Empty operator to perform that filtering if required. Return false if the field
// is not present or is empty
if (!string.IsNullOrEmpty(model?.Value))
{
return(string.Equals(model.Value, expectedValue, StringComparison.InvariantCultureIgnoreCase));
}
return(false);
}
public void InvalidDateTimeFilterTests(string submitValue, string filterFieldValue, string operatorType)
{
var expectedValue = new SubmissionMetaDataModel()
{
DisplayName = nameof(String),
Name = nameof(String),
Type = nameof(String),
Value = submitValue
};
var filterValue = new SearchTermModel()
{
FieldName = FilterConstants.FilterFieldTypes.StringType,
FieldType = FilterConstants.FilterFieldTypes.DateType,
FieldValue = filterFieldValue,
OperatorProperty = operatorType
};
Assert.Throws <ValidationException>(() => DateTimeFilter.MatchesFilter(expectedValue, filterValue));
}
public void OperatorPropertyNull_MatchesBoolFilterTest()
{
var expectedValue = new SubmissionMetaDataModel()
{
DisplayName = nameof(String),
Name = nameof(String),
Type = nameof(String),
Value = nameof(String),
};
var filterValue = new SearchTermModel()
{
FieldName = FilterConstants.FilterFieldTypes.StringType,
FieldType = FilterConstants.FilterFieldTypes.BooleanType,
FieldValue = FilterConstants.FilterFieldTypes.StringType,
OperatorProperty = null
};
Assert.Throws <NotImplementedException>(() => BooleanFilter.MatchesFilter(expectedValue, filterValue));
}
public static bool MatchesFilter(SubmissionMetaDataModel model, SearchTermModel filter)
{
switch (filter.OperatorProperty)
{
case FilterConstants.CommonFieldOperators.Equal:
{
return(IsEqual(model, filter.FieldValue));
}
case FilterConstants.CommonFieldOperators.NotEqual:
{
return(!IsEqual(model, filter.FieldValue));
}
default:
{
throw new NotImplementedException($"Filter for FieldName [{filter.FieldName}] has invalid OperatorProperty [{filter.OperatorProperty}]");
}
}
}
private bool MatchesFilterTest(string filterfieldValue, string modelValue, string operatorProperty)
{
var fieldName = "Test";
var filter = new SearchTermModel()
{
FieldName = fieldName,
FieldType = FilterConstants.FilterFieldTypes.StringType,
FieldValue = filterfieldValue,
OperatorProperty = operatorProperty
};
var model = new SubmissionMetaDataModel()
{
Name = fieldName,
Type = FilterHelpers.GetFieldType(filter),
Value = modelValue
};
return(StringFilter.MatchesFilter(model, filter));
}
public void ValidDateTimeFilterTests(string submitValue, string filterFieldValue, string operatorType, bool expectedResult)
{
var expectedValue = new SubmissionMetaDataModel()
{
DisplayName = nameof(String),
Name = nameof(String),
Type = nameof(String),
Value = submitValue
};
var filterValue = new SearchTermModel()
{
FieldName = FilterConstants.FilterFieldTypes.StringType,
FieldType = FilterConstants.FilterFieldTypes.DateType,
FieldValue = filterFieldValue,
OperatorProperty = operatorType
};
var result = DateTimeFilter.MatchesFilter(expectedValue, filterValue);
Assert.Equal(expectedResult, result);
}
public void DoesNotMatchBoolFilterTest(string submitValue, string fieldValue, bool expectedResult)
{
var expectedValue = new SubmissionMetaDataModel()
{
DisplayName = nameof(String),
Name = nameof(String),
Type = nameof(String),
Value = submitValue
};
var filterValue = new SearchTermModel()
{
FieldName = FilterConstants.FilterFieldTypes.StringType,
FieldType = FilterConstants.FilterFieldTypes.BooleanType,
FieldValue = fieldValue,
OperatorProperty = FilterConstants.CommonFieldOperators.NotEqual
};
var result = BooleanFilter.MatchesFilter(expectedValue, filterValue);
Assert.Equal(expectedResult, result);
}
